diff --git a/README.rst b/README.rst index 49845487..c8f70647 100644 --- a/README.rst +++ b/README.rst @@ -163,6 +163,40 @@ Based on the paper: *"Rates of convergence for the cluster tree."* In Advances in Neural Information Processing Systems, 2010. +---------------- +Branch detection +---------------- + +The hdbscan package supports a branch-detection post-processing step +by `Bot et al. `_. Cluster shapes, +such as branching structures, can reveal interesting patterns +that are not expressed in density-based cluster hierarchies. The +BranchDetector class mimics the HDBSCAN API and can be used to +detect branching hierarchies in clusters. It provides condensed +branch hierarchies, branch persistences, and branch memberships and +supports joblib's caching functionality. A notebook +`demonstrating the BranchDetector is available `_. + +Example usage: + +.. code:: python + + import hdbscan + from sklearn.datasets import make_blobs + + data, _ = make_blobs(1000) + + clusterer = hdbscan.HDBSCAN(branch_detection_data=True).fit(data) + branch_detector = hdbscan.BranchDetector().fit(clusterer) + branch_detector.cluster_approximation_graph_.plot(edge_width=0.1) + + +Based on the paper: + D. M. Bot, J. Peeters, J. Liesenborgs and J. Aerts + *"FLASC: A Flare-Sensitive Clustering Algorithm: Extending HDBSCAN\* for Detecting Branches in Clusters"* + Arxiv 2311.15887, 2023. + + ---------- Installing ---------- @@ -300,6 +334,24 @@ To reference the high performance algorithm developed in this library please cit organization={IEEE} } +If you used the branch-detection functionality in this codebase in a scientific publication and which to cite it, please use the `Arxiv preprint `_: + + D. M. Bot, J. Peeters, J. Liesenborgs and J. Aerts + *"FLASC: A Flare-Sensitive Clustering Algorithm: Extending HDBSCAN\* for Detecting Branches in Clusters"* + Arxiv 2311.15887, 2023. + +.. code:: bibtex + + @misc{bot2023flasc, + title={FLASC: A Flare-Sensitive Clustering Algorithm: Extending HDBSCAN* for Detecting Branches in Clusters}, + author={D. M. Bot and J. Peeters and J. Liesenborgs and J. Aerts}, + year={2023}, + eprint={2311.15887}, + archivePrefix={arXiv}, + primaryClass={cs.LG}, + url={https://arxiv.org/abs/2311.15887}, + } + --------- Licensing --------- diff --git a/docs/api.rst b/docs/api.rst index ff9fe976..a11b8285 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -36,3 +36,15 @@ and the prediction module. .. automodule:: hdbscan.prediction :members: + + +Branch detection +---------------- + +The branches module contains classes for detecting branches within clusters. + +.. automodule:: hdbscan.branches + :members: + +.. autoclass:: hdbscan.plots.ApproximationGraph + :members: diff --git a/docs/how_to_detect_branches.rst b/docs/how_to_detect_branches.rst new file mode 100644 index 00000000..80da6a29 --- /dev/null +++ b/docs/how_to_detect_branches.rst @@ -0,0 +1,242 @@ +How to detect banches in clusters +================================= + +HDBSCAN\* is often used to find subpopulations in exploratory data +analysis workflows. Not only clusters themselves, but also their shape +can represent meaningful subpopulations. For example, a Y-shaped cluster +may represent an evolving process with two distinct end-states. +Detecting these branches can reveal interesting patterns that are not +captured by density-based clustering. + +For example, HDBSCAN\* finds 4 clusters in the datasets below, which +does not inform us of the branching structure: + +.. image:: images/how_to_detect_branches_3_0.png + +Alternatively, HDBSCAN\*’s leaf clusters provide more detail. They +segment the points of different branches into distint clusters. However, +the partitioning and cluster hierarchy does not (necessarily) tell us how +those clusters combine into a larger shape. + +.. image:: images/how_to_detect_branches_5_0.png + +This is where the branch detection post-processing step comes into play. +The functionality is described in detail by `Bot et +al `__. It operates on the detected +clusters and extracts a branch-hierarchy analogous to HDBSCAN\*’s +condensed cluster hierarchy. The process is very similar to HDBSCAN\* +clustering, except that it operates on an in-cluster eccentricity rather +than a density measure. Where peaks in a density profile correspond to +clusters, the peaks in an eccentricity profile correspond to branches: + +.. image:: images/how_to_detect_branches_7_0.png + +Using the branch detection functionality is fairly straightforward. +First, run hdbscan with parameter ``branch_detection_data=True``. This +tells hdbscan to cache the internal data structures needed for the +branch detection process. Then, configure the ``BranchDetector`` class +and fit is with the HDBSCAN object. + +The resulting partitioning reflects subgroups for clusters and their +branches: + +.. code:: python + from hdbscan import HDBSCAN, BranchDetector + + clusterer = HDBSCAN(min_cluster_size=15, branch_detection_data=True).fit(data) + branch_detector = BranchDetector(min_branch_size=15).fit(clusterer) + plot(branch_detector.labels_) + +.. image:: images/how_to_detect_branches_9_0.png + + +Parameter selection +------------------- + +The ``BranchDetector``’s main parameters are very similar to HDBSCAN. +Most guidelines for tuning HDBSCAN\* also apply for the branch detector: + +- ``min_branch_size`` behaves like HDBSCAN\*’s ``min_cluster_size``. It + configures how many points branches need to contain. Values around 10 + to 25 points tend to work well. Lower values are useful when looking + for smaller structures. Higher values can be used to suppress noise + if present. +- ``branch_selection_method`` behaves like HDBSCAN\*’s + ``cluster_selection_method``. The leaf and Excess of Mass (EOM) + strategies are used to select branches from the condensed + hierarchies. By default, branches are only reflected in the final + labelling for clusters that have 3 or more branches (at least one + bifurcation). +- ``branch_selection_persistence`` replaces HDBSCAN\*’s + ``cluster_selection_epsilon``. This parameter can be used to suppress + branches with a short eccentricity range (y-range in the condensed + hierarchy plot). +- ``allow_single_branch`` behaves like HDBSCAN\*’s + ``allow_single_cluster`` and mostly affects the EOM selection + strategy. When enabled, clusters with bifurcations will be given a + single label if the root segment contains most eccentricity mass + (i.e., branches already merge far from the center and most poinst are + central). +- ``max_branch_size`` behaves like HDBSCAN\*’s ``max_cluster_size`` and + mostly affects the EOM selection strategy. Branches with more than + the specified number of points are skipped, selecting their + descendants in the hierarchy instead. + +Two parameters are unique to the ``BranchDetector`` class: + +- ``branch_detection_method`` determines which points are connected + within a cluster. Both density-based clustering and the branch detection + process need to determine which points are part of the same + density/eccentricity peak. HDBSCAN\* defines density in terms of the distance + between points, providing natural way to define which points are connected at + some density value. Eccentricity does not have such a connection. So, we use + information from the clusters to determine which points should be connected + instead. + + - The ``"core"`` method selects all edges that could be part of the + cluster’s minimum spanning tree under HDBSCAN\*’s mutual + reachability distance. This graph contains the detected MST and + all ``min_samples``-nearest neighbours. + - The ``"full"`` method connects all points with a mutual + reachability lower than the maximum distance in the cluster’s MST. + It represents all connectity at the moment the last point joins + the cluster. + + These methods differ in their sensitivity, noise robustness, and + computational cost. The ``"core"`` method usually needs slightly + higher ``min_branch_size`` values to suppress noisy branches than the + ``"full"`` method. It is a good choice when branches span large + density ranges. + +- ``label_sides_as_branches`` determines whether the sides of an + elongated cluster without bifurcations (l-shape) are represented as + distinct subgroups. By default a cluster needs to have one + bifurcation (Y-shape) before the detected branches are represented in + the final labelling. + + +Useful attributes +----------------- + +Like the HDBSCAN class, the BranchDetector class contains several useful +attributes for exploring datasets. + +Branch hierarchy +~~~~~~~~~~~~~~~~ + +Branch hierarchies reflect the tree-shape of clusters. Like the cluster +hierarchy, branch hierarchies can be used to interpret which branches +exist. In addition, they reflect how far apart branches merge into the +cluster. + +.. code:: python + + idx = np.argmax([len(x) for x in branch_detector.branch_persistences_]) + branch_detector.cluster_condensed_trees_[idx].plot( + select_clusters=True, selection_palette=["C3", "C4", "C5"] + ) + plt.ylabel("Eccentricity") + plt.title(f"Branches in cluster {idx}") + plt.show() + +.. image:: images/how_to_detect_branches_13_0.png + +The length of the branches also says something about the compactness / +elongatedness of clusters. For example, the branch hierarchy for the +orange ~-shaped cluster is quite different from the same hierarcy for +the central o-shaped cluster. + +.. code:: python + + plt.figure(figsize=(6, 3)) + plt.subplot(1, 2, 1) + idx = np.argmin([min(*x) for x in branch_detector.branch_persistences_]) + branch_detector.cluster_condensed_trees_[idx].plot(colorbar=False) + plt.ylim([0.3, 0]) + plt.ylabel("Eccentricity") + plt.title(f"Cluster {idx} (spherical)") + + plt.subplot(1, 2, 2) + idx = np.argmax([max(*x) for x in branch_detector.branch_persistences_]) + branch_detector.cluster_condensed_trees_[idx].plot(colorbar=False) + plt.ylim([0.3, 0]) + plt.ylabel("Eccentricity") + plt.title(f"Cluster {idx} (elongated)") + plt.show() + +.. image:: images/how_to_detect_branches_15_0.png + +Cluster approximation graphs +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Branches are detected using a graph that approximates the connectivity +within a cluster. These graphs are available in the +``cluster_approximation_graph_`` property and can be used to visualise +data and the branch-detection process. The plotting function is based on +the networkx API and uses networkx functionality to compute a layout if +positions are not provided. Using UMAP to compute positions can be +faster and more expressive. Several helper functions for exporting to +numpy, pandas, and networkx are available. + +For example, a figure with points coloured by the final labelling: + +.. code:: python + + g = branch_detector.cluster_approximation_graph_ + g.plot(positions=data, node_size=5, edge_width=0.2, edge_alpha=0.2) + plt.show() + +.. image:: images/how_to_detect_branches_17_0.png + +Or, a figure with the edges coloured by centrality: + +.. code:: python + + g.plot( + positions=data, + node_alpha=0, + edge_color="centrality", + edge_cmap="turbo", + edge_width=0.2, + edge_alpha=0.2, + edge_vmax=100, + ) + plt.show() + +.. image:: images/how_to_detect_branches_19_0.png + + +Approximate predict +------------------- + +A branch-aware ``approximate_predict_branch`` function is available to +predicts branch labels for new points. This function uses a fitted +BranchDetector object to first predict cluster labels and then the +branch labels. + +.. code:: python + + from hdbscan import approximate_predict_branch + + new_points = np.asarray([[0.4, 0.25], [0.23, 0.2], [-0.14, -0.2]]) + clusterer.generate_prediction_data() + labels, probs, cluster_labels, cluster_probs, branch_labels, branch_probs = ( + approximate_predict_branch(branch_detector, new_points) + ) + + plt.scatter( + new_points.T[0], + new_points.T[1], + 140, + labels % 10, + marker="p", + zorder=5, + cmap="tab10", + vmin=0, + vmax=9, + edgecolor="k", + ) + plot(branch_detector.labels_) + plt.show() + +.. image:: images/how_to_detect_branches_21_0.png diff --git a/docs/images/how_to_detect_branches_13_0.png b/docs/images/how_to_detect_branches_13_0.png new file mode 100644 index 00000000..16d409a4 Binary files /dev/null and b/docs/images/how_to_detect_branches_13_0.png differ diff --git a/docs/images/how_to_detect_branches_15_0.png b/docs/images/how_to_detect_branches_15_0.png new file mode 100644 index 00000000..63cf1f7e Binary files /dev/null and b/docs/images/how_to_detect_branches_15_0.png differ diff --git a/docs/images/how_to_detect_branches_17_0.png b/docs/images/how_to_detect_branches_17_0.png new file mode 100644 index 00000000..05c5c21d Binary files /dev/null and b/docs/images/how_to_detect_branches_17_0.png differ diff --git a/docs/images/how_to_detect_branches_19_0.png b/docs/images/how_to_detect_branches_19_0.png new file mode 100644 index 00000000..206e0828 Binary files /dev/null and b/docs/images/how_to_detect_branches_19_0.png differ diff --git a/docs/images/how_to_detect_branches_21_0.png b/docs/images/how_to_detect_branches_21_0.png new file mode 100644 index 00000000..a1d4e47a Binary files /dev/null and b/docs/images/how_to_detect_branches_21_0.png differ diff --git a/docs/images/how_to_detect_branches_3_0.png b/docs/images/how_to_detect_branches_3_0.png new file mode 100644 index 00000000..6ff165df Binary files /dev/null and b/docs/images/how_to_detect_branches_3_0.png differ diff --git a/docs/images/how_to_detect_branches_5_0.png b/docs/images/how_to_detect_branches_5_0.png new file mode 100644 index 00000000..fdb6c5de Binary files /dev/null and b/docs/images/how_to_detect_branches_5_0.png differ diff --git a/docs/images/how_to_detect_branches_7_0.png b/docs/images/how_to_detect_branches_7_0.png new file mode 100644 index 00000000..a331a189 Binary files /dev/null and b/docs/images/how_to_detect_branches_7_0.png differ diff --git a/docs/images/how_to_detect_branches_9_0.png b/docs/images/how_to_detect_branches_9_0.png new file mode 100644 index 00000000..cd199edf Binary files /dev/null and b/docs/images/how_to_detect_branches_9_0.png differ diff --git a/docs/index.rst b/docs/index.rst index c3434561..5f2c8d23 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -26,6 +26,7 @@ User Guide / Tutorial soft_clustering how_to_use_epsilon dbscan_from_hdbscan + how_to_detect_branches faq Background on Clustering with HDBSCAN diff --git a/hdbscan/__init__.py b/hdbscan/__init__.py index 2f6e10c9..99ea7211 100644 --- a/hdbscan/__init__.py +++ b/hdbscan/__init__.py @@ -5,5 +5,8 @@ membership_vector, all_points_membership_vectors, approximate_predict_scores) +from .branches import (BranchDetector, + detect_branches_in_clusters, + approximate_predict_branch) diff --git a/hdbscan/_hdbscan_linkage.pyx b/hdbscan/_hdbscan_linkage.pyx index 738ed6a2..66152e38 100644 --- a/hdbscan/_hdbscan_linkage.pyx +++ b/hdbscan/_hdbscan_linkage.pyx @@ -76,8 +76,8 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_vector( cdef np.intp_t current_node cdef np.intp_t source_node - cdef np.intp_t right_node - cdef np.intp_t left_node + cdef np.intp_t right_node, right_source + cdef np.intp_t left_node, left_source cdef np.intp_t new_node cdef np.intp_t i cdef np.intp_t j @@ -124,7 +124,7 @@ cpdef np.ndarray[np.double_t, ndim=2] mst_linkage_core_vector( continue right_value = current_distances[j] - right_source = current_sources[j] + right_source = current_sources[j] left_value = dist_metric.dist(&raw_data_ptr[num_features * current_node], diff --git a/hdbscan/_hdbscan_tree.pyx b/hdbscan/_hdbscan_tree.pyx index aeb40518..d8746d53 100644 --- a/hdbscan/_hdbscan_tree.pyx +++ b/hdbscan/_hdbscan_tree.pyx @@ -301,6 +301,65 @@ cdef max_lambdas(np.ndarray tree): return deaths_arr +cdef max_eccentricities(np.ndarray tree, np.intp_t num_points): + """Maximum eccentricity for each segment in the branch hierarchy. + + Differs from max_lambda by using the max value in the sub-tree rather + than per segment. + """ + cdef np.ndarray sorted_parent_data + cdef np.ndarray[np.intp_t, ndim=1] sorted_parents + cdef np.ndarray[np.intp_t, ndim=1] sorted_children + cdef np.ndarray[np.double_t, ndim=1] sorted_lambdas + cdef np.intp_t[:] sorted_parents_view + cdef np.intp_t[:] sorted_child_view + cdef np.double_t[:] sorted_ecc_view + + cdef np.intp_t parent, child + cdef np.intp_t current_parent + cdef np.float64_t eccentricity + cdef np.float64_t max_lambda + + cdef np.ndarray[np.double_t, ndim=1] births_arr + cdef np.double_t[::1] births + + cdef np.intp_t largest_parent = tree['parent'].max() + + sorted_parent_data = np.sort(tree[['parent', 'lambda_val', 'child']], axis=0) + sorted_parents = sorted_parent_data['parent'] + sorted_children = sorted_parent_data['child'] + sorted_lambdas = sorted_parent_data['lambda_val'] + sorted_parents_view = sorted_parents[::-1] + sorted_child_view = sorted_children[::-1] + sorted_ecc_view = sorted_lambdas[::-1] + + births_arr = np.zeros(largest_parent + 1, dtype=np.double) + births = births_arr + + current_parent = -1 + max_eccentricity = 0 + + for parent, child, eccentricity in zip(sorted_parents_view, sorted_child_view, sorted_ecc_view): + # Use maximum density (= eccentricity) within branch rather than + # the maximum density (= eccentricity) of this segment in the condensed tree. + # Need child to be process first -> iterate from high to low parent! + if child >= num_points: + eccentricity = births[child] + if parent == current_parent: + max_eccentricity = max(max_eccentricity, eccentricity) + elif current_parent != -1: + births[current_parent] = max_eccentricity + current_parent = parent + max_eccentricity = eccentricity + else: + # Initialize + current_parent = parent + max_eccentricity = eccentricity + + births[current_parent] = max_eccentricity # value for last parent + return births_arr + + cdef class TreeUnionFind (object): cdef np.ndarray _data_arr @@ -388,8 +447,8 @@ cpdef np.ndarray[np.intp_t, ndim=1] labelling_at_cut( cluster = num_points for row in linkage: if row[2] < cut: - union_find.union_( row[0], cluster) - union_find.union_( row[1], cluster) + union_find.union_(np.intp(row[0]), cluster) + union_find.union_(np.intp(row[1]), cluster) cluster += 1 cluster_size = np.zeros(cluster, dtype=np.intp) @@ -483,10 +542,8 @@ cdef np.ndarray[np.intp_t, ndim=1] do_labelling( return result_arr -cdef get_probabilities(np.ndarray tree, dict cluster_map, np.ndarray labels): - +cdef get_probabilities(np.ndarray tree, dict cluster_map, np.ndarray labels, np.ndarray deaths): cdef np.ndarray[np.double_t, ndim=1] result - cdef np.ndarray[np.double_t, ndim=1] deaths cdef np.ndarray[np.double_t, ndim=1] lambda_array cdef np.ndarray[np.intp_t, ndim=1] child_array cdef np.ndarray[np.intp_t, ndim=1] parent_array @@ -503,7 +560,6 @@ cdef get_probabilities(np.ndarray tree, dict cluster_map, np.ndarray labels): lambda_array = tree['lambda_val'] result = np.zeros(labels.shape[0]) - deaths = max_lambdas(tree) root_cluster = parent_array.min() for n in range(tree.shape[0]): @@ -606,6 +662,7 @@ cpdef np.ndarray get_stability_scores(np.ndarray labels, set clusters, return result + cpdef list recurse_leaf_dfs(np.ndarray cluster_tree, np.intp_t current_node): children = cluster_tree[cluster_tree['parent'] == current_node]['child'] if len(children) == 0: @@ -620,22 +677,24 @@ cpdef list get_cluster_tree_leaves(np.ndarray cluster_tree): root = cluster_tree['parent'].min() return recurse_leaf_dfs(cluster_tree, root) + cpdef np.intp_t traverse_upwards(np.ndarray cluster_tree, np.double_t cluster_selection_epsilon, np.intp_t leaf, np.intp_t allow_single_cluster): root = cluster_tree['parent'].min() - parent = cluster_tree[cluster_tree['child'] == leaf]['parent'] + parent = cluster_tree[cluster_tree['child'] == leaf]['parent'][0] if parent == root: if allow_single_cluster: return parent else: return leaf #return node closest to root - parent_eps = 1/cluster_tree[cluster_tree['child'] == parent]['lambda_val'] + parent_eps = 1/cluster_tree[cluster_tree['child'] == parent]['lambda_val'][0] if parent_eps > cluster_selection_epsilon: return parent else: return traverse_upwards(cluster_tree, cluster_selection_epsilon, parent, allow_single_cluster) + cpdef set epsilon_search(set leaves, np.ndarray cluster_tree, np.double_t cluster_selection_epsilon, np.intp_t allow_single_cluster): selected_clusters = list() @@ -656,6 +715,78 @@ cpdef set epsilon_search(set leaves, np.ndarray cluster_tree, np.double_t cluste return set(selected_clusters) + +cpdef np.ndarray simplify_branch_hierarchy(np.ndarray condensed_tree, + np.double_t persistence_threshold): + """Iteratively remove branches with persistence below threshold. + + Takes the place of epsilon_search which cannot deal with non-zero births. + """ + cdef bint flag + cdef np.intp_t leaf, sibling, parent, leaf_idx, sibling_idx + cdef np.double_t persistence + cdef np.ndarray cluster_tree, child_ids + cdef list leaves, persistences + cdef set processed + cdef np.intp_t num_points = condensed_tree['parent'].min() + + cdef np.ndarray[np.double_t, ndim=1] births_arr = max_eccentricities(condensed_tree, num_points) + cdef np.double_t[::1] births = births_arr + + while True: + processed = set() + cluster_tree = condensed_tree[condensed_tree['child_size'] > 1] + leaves = get_cluster_tree_leaves(cluster_tree) + persistences = [ + births[leaf] - cluster_tree['lambda_val'][cluster_tree['child'] == leaf][0] + for leaf in leaves + ] + flag = True + for leaf, persistence in zip(leaves, persistences): + if leaf in processed: + continue + if persistence < persistence_threshold: + flag = False + # Find parent and sibling + leaf_idx = np.argmax(condensed_tree['child'] == leaf) + parent = condensed_tree['parent'][leaf_idx] + child_ids = np.where((condensed_tree['parent'] == parent) & (condensed_tree['child_size'] > 1))[0] + sibling_idx = child_ids[1] if child_ids[0] == leaf_idx else child_ids[0] + sibling = condensed_tree['child'][sibling_idx] + + # Reset leaf and sibling rows + condensed_tree['child'][leaf_idx] = -999 + condensed_tree['child'][sibling_idx] = -999 + condensed_tree['parent'][leaf_idx] = -999 + condensed_tree['parent'][sibling_idx] = -999 + + # Update parent-values to reflect the merge + condensed_tree['parent'][(condensed_tree['parent'] == leaf)] = parent + condensed_tree['parent'][(condensed_tree['parent'] == sibling)] = parent + + processed.add(leaf) + processed.add(sibling) + + # Remove marked rows + condensed_tree = condensed_tree[condensed_tree['parent'] != -999] + if flag: + break + + return remap_cluster_ids(condensed_tree, num_points) + + +cdef np.ndarray remap_cluster_ids(np.ndarray condensed_tree, np.intp_t num_points): + """Ensures segments are numbered consequetively from 0 to n_clusters-1.""" + max_parent = condensed_tree['parent'].max() + id_map = np.empty(max_parent + 1) + id_map[:num_points] = np.arange(num_points) + remaining_parents = np.unique(condensed_tree['parent']) + id_map[remaining_parents] = num_points + np.arange(remaining_parents.shape[0]) + condensed_tree['parent'] = id_map[condensed_tree['parent']] + condensed_tree['child'] = id_map[condensed_tree['child']] + return condensed_tree + + cpdef tuple get_clusters(np.ndarray tree, dict stability, cluster_selection_method='eom', allow_single_cluster=False, @@ -718,6 +849,7 @@ cpdef tuple get_clusters(np.ndarray tree, dict stability, cdef np.intp_t num_points cdef np.ndarray labels cdef np.double_t max_lambda + cdef np.ndarray[np.double_t, ndim=1] deaths # Assume clusters are ordered by numeric id equivalent to # a topological sort of the tree; This is valid given the @@ -725,16 +857,16 @@ cpdef tuple get_clusters(np.ndarray tree, dict stability, # if you do, change this accordingly! if allow_single_cluster: node_list = sorted(stability.keys(), reverse=True) - node_list = [int(n) for n in node_list] else: node_list = sorted(stability.keys(), reverse=True)[:-1] - node_list = [int(n) for n in node_list] + node_list = [int(n) for n in node_list] # (exclude root) cluster_tree = tree[tree['child_size'] > 1] is_cluster = {cluster: True for cluster in node_list} num_points = np.max(tree[tree['child_size'] == 1]['child']) + 1 max_lambda = np.max(tree['lambda_val']) + deaths = max_lambdas(tree) if max_cluster_size <= 0: max_cluster_size = num_points + 1 # Set to a value that will never be triggered @@ -802,7 +934,131 @@ cpdef tuple get_clusters(np.ndarray tree, dict stability, labels = do_labelling(tree, clusters, cluster_map, allow_single_cluster, cluster_selection_epsilon, match_reference_implementation) - probs = get_probabilities(tree, reverse_cluster_map, labels) + probs = get_probabilities(tree, reverse_cluster_map, labels, deaths) stabilities = get_stability_scores(labels, clusters, stability, max_lambda) return (labels, probs, stabilities) + + +cpdef tuple get_branches(np.ndarray tree, + dict stability, + branch_selection_method='eom', + allow_single_branch=False, + max_branch_size=0): + """Extracts branches from a branch condensed tree. + + Given a tree and stability dict, produce the branch labels + (and probabilities) for a flat "clustering" based on the chosen + branch selection method. + + Parameters + ---------- + tree : numpy recarray + The condensed tree to extract flat clusters from. + Uses lambda_val key to store eccentricity values. + stability : dict + A dictionary mapping cluster_ids to stability values + branch_selection_method : string, optional (default 'eom') + The method of selecting clusters. The default is the + Excess of Mass algorithm specified by 'eom'. The alternate + option is 'leaf'. + allow_single_branch : boolean, optional (default False) + Whether to allow a single branch to be selected by the + Excess of Mass algorithm. + max_branch_size: int, optional (default 0) + The maximum size for clusters located by the EOM clusterer. Can + be overridden by the branch_selection_persistence parameter in + rare cases. + + Returns + ------- + labels : ndarray (n_samples,) + An integer array of branch labels, with -1 denoting noise. + probabilities : ndarray (n_samples,) + The cluster membership strength of each sample. + stabilities : ndarray (n_clusters,) + The cluster coherence strengths of each branch. + """ + cdef list node_list + cdef np.ndarray cluster_tree + cdef np.ndarray child_selection + cdef dict is_cluster + cdef dict cluster_sizes + cdef float subtree_stability + cdef np.intp_t node + cdef np.intp_t sub_node + cdef np.intp_t cluster + cdef np.intp_t num_points + cdef np.ndarray labels + cdef np.double_t max_eccentricity + cdef np.ndarray[np.double_t, ndim=1] births + + # Assume clusters are ordered by numeric id equivalent to + # a topological sort of the tree; This is valid given the + # current implementation above, so don't change that ... or + # if you do, change this accordingly! + if allow_single_branch: + node_list = sorted(stability.keys(), reverse=True) + else: + node_list = sorted(stability.keys(), reverse=True)[:-1] # (exclude root) + node_list = [int(n) for n in node_list] + + cluster_tree = tree[tree['child_size'] > 1] + is_cluster = {cluster: True for cluster in node_list} + num_points = np.min(tree['parent']) + max_eccentricity = np.max(tree['lambda_val']) + births = max_eccentricities(tree, num_points) + + if max_branch_size <= 0: + max_branch_size = num_points + 1 # Set to a value that will never be triggered + cluster_sizes = { + child: child_size + for child, child_size in zip(cluster_tree['child'], cluster_tree['child_size']) + } + if allow_single_branch: + # Compute cluster size for the root node + cluster_sizes[node_list[-1]] = np.sum( + cluster_tree[cluster_tree['parent'] == node_list[-1]]['child_size'] + ) + + if branch_selection_method == 'eom': + for node in node_list: + child_selection = (cluster_tree['parent'] == node) + subtree_stability = np.sum([ + stability[child] for + child in cluster_tree['child'][child_selection]]) + if subtree_stability > stability[node] or cluster_sizes[node] > max_branch_size: + is_cluster[node] = False + stability[node] = subtree_stability + else: + for sub_node in bfs_from_cluster_tree(cluster_tree, node): + if sub_node != node: + is_cluster[sub_node] = False + elif branch_selection_method == 'leaf': + leaves = get_cluster_tree_leaves(cluster_tree) + selected_clusters = set(leaves) + + # Allow single leaf + if len(selected_clusters) == 0 and allow_single_branch: + for c in is_cluster: + is_cluster[c] = False + is_cluster[tree['parent'].min()] = True + else: + for c in is_cluster: + if c in selected_clusters: + is_cluster[c] = True + else: + is_cluster[c] = False + else: + raise ValueError('Invalid Cluster Selection Method: %s\n' + 'Should be one of: "eom", "leaf"\n') + + clusters = set([c for c in is_cluster if is_cluster[c]]) + cluster_map = {c: n for n, c in enumerate(sorted(list(clusters)))} + reverse_cluster_map = {n: c for c, n in cluster_map.items()} + + labels = do_labelling(tree, clusters, cluster_map, allow_single_branch, 0.0, False) + probs = get_probabilities(tree, reverse_cluster_map, labels, births) + stabilities = get_stability_scores(labels, clusters, stability, max_eccentricity) + + return (labels, probs, stabilities) \ No newline at end of file diff --git a/hdbscan/branches.py b/hdbscan/branches.py new file mode 100644 index 00000000..e0643859 --- /dev/null +++ b/hdbscan/branches.py @@ -0,0 +1,1184 @@ +# Support branch detection within clusters. +import numpy as np + +from sklearn.base import BaseEstimator, ClusterMixin +from sklearn.neighbors import KDTree, BallTree +from scipy.sparse import coo_array +from scipy.sparse.csgraph import minimum_spanning_tree +from joblib import Memory +from joblib import Parallel, delayed +from joblib.parallel import cpu_count +from .dist_metrics import DistanceMetric +from ._hdbscan_linkage import label +from .plots import CondensedTree, SingleLinkageTree, ApproximationGraph +from .prediction import approximate_predict +from ._hdbscan_tree import ( + get_branches, + condense_tree, + recurse_leaf_dfs, + compute_stability, + simplify_branch_hierarchy, +) + + +class BranchDetectionData(object): + """Input data for branch detection functionality. + + Recreates and caches internal data structures from the clustering stage. + + Parameters + ---------- + + data : array (n_samples, n_features) + The original data set that was clustered. + + labels : array (n_samples) + The cluster labels for every point in the data set. + + min_samples : int + The min_samples value used in clustering. + + tree_type : string, optional + Which type of space tree to use for core distance computation. + One of: + * ``kdtree`` + * ``balltree`` + + metric : string, optional + The metric used to determine distance for the clustering. + This is the metric that will be used for the space tree to determine + core distances etc. + + **kwargs : + Any further arguments to the metric. + + Attributes + ---------- + + all_finite : bool + Whether the data set contains any infinite or NaN values. + + finite_index : array (n_samples) + The indices of the finite data points in the original data set. + + internal_to_raw : dict + A mapping from the finite data set indices to the original data set. + + tree : KDTree or BallTree + A space partitioning tree that can be queried for nearest neighbors if + the metric is supported by a KDTree or BallTree. + + neighbors : array (n_samples, min_samples) + The nearest neighbor for every non-noise point in the original data set. + + core_distances : array (n_samples) + The core distance for every non-noise point in the original data set. + + dist_metric : callable + Accelerated distance metric function. + """ + + _tree_type_map = {"kdtree": KDTree, "balltree": BallTree} + + def __init__( + self, + data, + all_finite, + finite_index, + labels, + min_samples, + tree_type="kdtree", + metric="euclidean", + **kwargs, + ): + # Select finite data points + self.all_finite = all_finite + self.finite_index = finite_index + clean_data = data.astype(np.float64) + if not all_finite: + labels = labels[finite_index] + clean_data = clean_data[finite_index] + self.internal_to_raw = { + x: y for x, y in zip(range(len(finite_index)), finite_index) + } + else: + self.internal_to_raw = None + + # Construct tree + self.tree = self._tree_type_map[tree_type](clean_data, metric=metric, **kwargs) + self.dist_metric = DistanceMetric.get_metric(metric, **kwargs) + + # Allocate to maintain data point indices + self.core_distances = np.full(clean_data.shape[0], np.nan) + self.neighbors = np.full((clean_data.shape[0], min_samples), -1, dtype=np.int64) + + # Find neighbours for non-noise points + noise_mask = labels != -1 + if noise_mask.any(): + distances, self.neighbors[noise_mask, :] = self.tree.query( + clean_data[noise_mask], k=min_samples + ) + self.core_distances[noise_mask] = distances[:, -1] + + +def detect_branches_in_clusters( + clusterer, + min_branch_size=None, + allow_single_branch=False, + branch_detection_method="full", + branch_selection_method="eom", + branch_selection_persistence=0.0, + max_branch_size=0, + label_sides_as_branches=False, +): + """ + Performs a flare-detection post-processing step to detect branches within + clusters [1]_. + + For each cluster, a graph is constructed connecting the data points based on + their mutual reachability distances. Each edge is given a centrality value + based on how far it lies from the cluster's center. Then, the edges are + clustered as if that centrality was a distance, progressively removing the + 'center' of each cluster and seeing how many branches remain. + + Parameters + ---------- + + clusterer : hdbscan.HDBSCAN + The clusterer object that has been fit to the data with branch detection + data generated. + + min_branch_size : int, optional (default=None) + The minimum number of samples in a group for that group to be + considered a branch; groupings smaller than this size will seen as + points falling out of a branch. Defaults to the clusterer's min_cluster_size. + + allow_single_branch : bool, optional (default=False) + Analogous to ``allow_single_cluster``. + + branch_detection_method : str, optional (default=``full``) + Deteremines which graph is conctructed to detect branches with. Valid + values are, ordered by increasing computation cost and decreasing + sensitivity to noise: + - ``core``: Contains the edges that connect each point to all other + points within a mutual reachability distance lower than or equal to + the point's core distance. This is the cluster's subgraph of the + k-NN graph over the entire data set (with k = ``min_samples``). + - ``full``: Contains all edges between points in each cluster with a + mutual reachability distance lower than or equal to the distance of + the most-distance point in each cluster. These graphs represent the + 0-dimensional simplicial complex of each cluster at the first point in + the filtration where they contain all their points. + + branch_selection_method : str, optional (default='eom') + The method used to select branches from the cluster's condensed tree. + The standard approach for FLASC is to use the ``eom`` approach. + Options are: + * ``eom`` + * ``leaf`` + + branch_selection_persistence: float, optional (default=0.0) + An eccentricity persistence threshold. Branches with a persistence below + this value will be merged. See [3]_ for more information. Note that this + should not be used if we want to predict the cluster labels for new + points in future (e.g. using approximate_predict), as the + :func:`~flasc.prediction.approximate_predict` function is not aware of + this argument. + + max_branch_size : int, optional (default=0) + A limit to the size of clusters returned by the ``eom`` algorithm. + Has no effect when using ``leaf`` clustering (where clusters are + usually small regardless). Note that this should not be used if we + want to predict the cluster labels for new points in future (e.g. using + :func:`~flasc.prediction.approximate_predict`), as that function is + not aware of this argument. + + label_sides_as_branches : bool, optional (default=False), + When this flag is False, branches are only labelled for clusters with at + least three branches (i.e., at least y-shapes). Clusters with only two + branches represent l-shapes. The two branches describe the cluster's + outsides growing towards each other. Enableing this flag separates these + branches from each other in the produced labelling. + + Returns + ------- + labels : np.ndarray, shape (n_samples, ) + Labels that differentiate all subgroups (clusters and branches). Noisy + samples are given the label -1. + + probabilities : np.ndarray, shape (n_samples, ) + Probabilities considering both cluster and branch membership. Noisy + samples are assigned 0. + + branch_labels : np.ndarray, shape (n_samples, ) + Branch labels for each point. Noisy samples are given the label -1. + + branch_probabilities : np.ndarray, shape (n_samples, ) + Branch membership strengths for each point. Noisy samples are + assigned 0. + + branch_persistences : tuple (n_clusters) + A branch persistence (eccentricity range) for each detected branch. + + cluster_approximation_graphs : tuple (n_clusters) + The graphs used to detect branches in each cluster stored as a numpy + array with four columns: source, target, centrality, mutual reachability + distance. Points are labelled by their row-index into the input data. + The edges contained in the graphs depend on the ``branch_detection_method``: + - ``core``: Contains the edges that connect each point to all other + points in a cluster within a mutual reachability distance lower than + or equal to the point's core distance. This is an extension of the + minimum spanning tree introducing only edges with equal distances. The + reachability distance introduces ``num_points`` * ``min_samples`` of + such edges. + - ``full``: Contains all edges between points in each cluster with a + mutual reachability distance lower than or equal to the distance of + the most-distance point in each cluster. These graphs represent the + 0-dimensional simplicial complex of each cluster at the first point in + the filtration where they contain all their points. + + cluster_condensed_trees : tuple (n_clusters) + A condensed branch hierarchy for each cluster produced during the + branch detection step. Data points are numbered with in-cluster ids. + + cluster_linkage_trees : tuple (n_clusters) + A single linkage tree for each cluster produced during the branch + detection step, in the scipy hierarchical clustering format. + (see http://docs.scipy.org/doc/scipy/reference/cluster.hierarchy.html). + Data points are numbered with in-cluster ids. + + cluster_centralities : np.ndarray, shape (n_samples, ) + Centrality values for each point in a cluster. Overemphasizes points' + eccentricity within the cluster as the values are based on minimum + spanning trees that do not contain the equally distanced edges resulting + from the mutual reachability distance. + + cluster_points : list (n_clusters) + The data point row indices for each cluster. + + References + ---------- + .. [1] Bot, D. M., Peeters, J., Liesenborgs J., & Aerts, J. (2023, November). + FLASC: A Flare-Sensitive Clustering Algorithm: Extending HDBSCAN* for + Detecting Branches in Clusters. arXiv:2311.15887 + """ + # Check clusterer state + if clusterer._min_spanning_tree is None: + raise ValueError( + "Clusterer does not have an explicit minimum spannning tree!" + " Try fitting with branch_detection_data=True or" + " gen_min_span_tree=True set." + ) + if clusterer.branch_detection_data_ is None: + raise ValueError( + "Clusterer does not have branch detection data!" + " Try fitting with branch_detection_data=True set," + " or run generate_branch_detection_data on the clusterer" + ) + + # Validate parameters + if min_branch_size is None: + min_branch_size = clusterer.min_cluster_size + branch_selection_persistence = float(branch_selection_persistence) + if not (np.issubdtype(type(min_branch_size), np.integer) and min_branch_size >= 2): + raise ValueError( + f"min_branch_size must be an integer greater or equal " + f"to 2, {min_branch_size} given." + ) + if not ( + np.issubdtype(type(branch_selection_persistence), np.floating) + and branch_selection_persistence >= 0.0 + ): + raise ValueError( + f"branch_selection_persistence must be a float greater or equal to " + f"0.0, {branch_selection_persistence} given." + ) + if branch_selection_method not in ("eom", "leaf"): + raise ValueError( + f"Invalid branch_selection_method: {branch_selection_method}\n" + f'Should be one of: "eom", "leaf"\n' + ) + if branch_detection_method not in ("core", "full"): + raise ValueError( + f"Invalid ``branch_detection_method``: {branch_detection_method}\n" + 'Should be one of: "core", "full"\n' + ) + + # Extract state + memory = clusterer.memory + if isinstance(memory, str): + memory = Memory(memory, verbose=0) + num_clusters = len(clusterer.cluster_persistence_) + labels = clusterer.labels_ + probabilities = clusterer.probabilities_ + if not clusterer.branch_detection_data_.all_finite: + finite_index = clusterer.branch_detection_data_.finite_index + labels = labels[finite_index] + probabilities = probabilities[finite_index] + + # Configure parallelization + run_core = branch_detection_method == "core" + num_jobs = clusterer.core_dist_n_jobs + if num_jobs < 1: + num_jobs = max(cpu_count() + 1 + num_jobs, 1) + thread_pool = ( + SequentialPool() if run_core else Parallel(n_jobs=num_jobs, max_nbytes=None) + ) + + # Detect branches + ( + cluster_points, + cluster_centralities, + cluster_linkage_trees, + cluster_approximation_graphs, + ) = memory.cache(_compute_branch_linkage, ignore=["thread_pool"])( + labels, + probabilities, + clusterer._min_spanning_tree, + clusterer.branch_detection_data_.tree, + clusterer.branch_detection_data_.neighbors, + clusterer.branch_detection_data_.core_distances, + clusterer.branch_detection_data_.dist_metric, + num_clusters, + thread_pool, + run_core=run_core, + ) + ( + branch_labels, + branch_probabilities, + branch_persistences, + cluster_condensed_trees, + ) = memory.cache(_compute_branch_segmentation, ignore=["thread_pool"])( + cluster_linkage_trees, + thread_pool, + min_branch_size=min_branch_size, + allow_single_branch=allow_single_branch, + branch_selection_method=branch_selection_method, + branch_selection_persistence=branch_selection_persistence, + max_branch_size=max_branch_size, + ) + ( + labels, + probabilities, + branch_labels, + branch_probabilities, + cluster_centralities, + ) = memory.cache(_update_labelling)( + labels, + probabilities, + cluster_points, + cluster_centralities, + branch_labels, + branch_probabilities, + branch_persistences, + label_sides_as_branches=label_sides_as_branches, + ) + + # Maintain data indices for non-finite data + if not clusterer.branch_detection_data_.all_finite: + internal_to_raw = clusterer.branch_detection_data_.internal_to_raw + _remap_point_lists(cluster_points, internal_to_raw) + _remap_edge_lists(cluster_approximation_graphs, internal_to_raw) + + num_points = len(clusterer.labels_) + labels = _remap_labels(labels, finite_index, num_points) + probabilities = _remap_probabilities(probabilities, finite_index, num_points) + branch_labels = _remap_labels(branch_labels, finite_index, num_points) + branch_probabilities = _remap_probabilities( + branch_probabilities, finite_index, num_points + ) + cluster_centralities = _remap_probabilities( + cluster_centralities, finite_index, num_points + ) + + return ( + # Combined result + labels, + probabilities, + # Branching result + branch_labels, + branch_probabilities, + branch_persistences, + # Clusters to branches + cluster_approximation_graphs, + cluster_condensed_trees, + cluster_linkage_trees, + cluster_centralities, + cluster_points, + ) + + +def _compute_branch_linkage( + cluster_labels, + cluster_probabilities, + min_spanning_tree, + space_tree, + neighbors, + core_distances, + dist_metric, + num_clusters, + thread_pool, + run_core=False, +): + result = thread_pool( + delayed(_compute_branch_linkage_of_cluster)( + cluster_labels, + cluster_probabilities, + min_spanning_tree, + space_tree, + neighbors, + core_distances, + dist_metric, + run_core, + cluster_id, + ) + for cluster_id in range(num_clusters) + ) + if len(result): + return tuple(zip(*result)) + return (), (), (), () + + +def _compute_branch_linkage_of_cluster( + cluster_labels, + cluster_probabilities, + min_spanning_tree, + space_tree, + neighbors, + core_distances, + dist_metric, + run_core, + cluster_id, +): + """Detect branches within one cluster.""" + # List points within cluster + cluster_mask = cluster_labels == cluster_id + cluster_points = np.where(cluster_mask)[0] + in_cluster_ids = np.full(cluster_labels.shape[0], -1, dtype=np.double) + in_cluster_ids[cluster_points] = np.arange(len(cluster_points), dtype=np.double) + + # Extract MST edges within cluster + parent_mask = cluster_labels[min_spanning_tree[:, 0].astype(np.intp)] == cluster_id + child_mask = cluster_labels[min_spanning_tree[:, 1].astype(np.intp)] == cluster_id + cluster_mst = min_spanning_tree[parent_mask & child_mask] + + # Compute in cluster centrality + points = space_tree.data.base[cluster_points] + centroid = np.average(points, weights=cluster_probabilities[cluster_mask], axis=0) + centralities = dist_metric.pairwise(centroid[None], points)[0, :] + centralities = 1 / centralities + + # Construct cluster approximation graph + if run_core: + edges = _extract_core_cluster_graph( + cluster_mst, core_distances, neighbors[cluster_points], in_cluster_ids + ) + else: + max_dist = cluster_mst.T[2].max() + edges = _extract_full_cluster_graph( + space_tree, core_distances, cluster_points, in_cluster_ids, max_dist + ) + np.maximum( + centralities[edges[:, 0].astype(np.intp)], + centralities[edges[:, 1].astype(np.intp)], + edges[:, 2], + ) + + # Extract centrality MST and compute single linkage + centrality_mst = minimum_spanning_tree( + coo_array( + (edges[:, 2], (edges[:, 0].astype(np.int32), edges[:, 1].astype(np.int32))), + shape=(len(cluster_points), len(cluster_points)), + ) + ).tocoo() + centrality_mst = np.column_stack( + (centrality_mst.row, centrality_mst.col, centrality_mst.data) + ) + centrality_mst = centrality_mst[np.argsort(centrality_mst.T[2]), :] + linkage_tree = label(centrality_mst) + + # Re-label edges with data ids + edges[:, 0] = cluster_points[edges[:, 0].astype(np.intp)] + edges[:, 1] = cluster_points[edges[:, 1].astype(np.intp)] + + # Return values + return cluster_points, centralities, linkage_tree, edges + + +def _extract_core_cluster_graph( + cluster_spanning_tree, + core_distances, + neighbors, + in_cluster_ids, +): + """Create a graph connecting all points within each point's core distance.""" + # Allocate output (won't be filled completely) + cluster_spanning_tree_view = cluster_spanning_tree + num_points = neighbors.shape[0] + num_neighbors = neighbors.shape[1] + count = cluster_spanning_tree_view.shape[0] + edges = np.zeros((count + num_points * num_neighbors, 4), dtype=np.double) + + # Fill (undirected) MST edges with within-cluster-ids + mst_parents = in_cluster_ids[cluster_spanning_tree[:, 0].astype(np.intp)] + mst_children = in_cluster_ids[cluster_spanning_tree[:, 1].astype(np.intp)] + np.minimum(mst_parents, mst_children, edges[:count, 0]) + np.maximum(mst_parents, mst_children, edges[:count, 1]) + + # Fill neighbors with within-cluster-ids + core_parent = np.repeat(np.arange(num_points, dtype=np.double), num_neighbors) + core_children = in_cluster_ids[neighbors.flatten()] + np.minimum(core_parent, core_children, edges[count:, 0]) + np.maximum(core_parent, core_children, edges[count:, 1]) + + # Fill mutual reachabilities + edges[:count, 3] = cluster_spanning_tree[:, 2] + np.maximum( + core_distances[edges[count:, 0].astype(np.intp)], + core_distances[edges[count:, 1].astype(np.intp)], + edges[count:, 3], + ) + + # Extract unique edges that stay within the cluster + edges = np.unique(edges[edges[:, 0] > -1.0, :], axis=0) + return edges + + +def _extract_full_cluster_graph( + space_tree, core_distances, cluster_points, in_cluster_ids, max_dist +): + # Query KDTree/BallTree for neighours within the distance + children_map, distances_map = space_tree.query_radius( + space_tree.data.base[cluster_points], r=max_dist + 1e-8, return_distance=True + ) + + # Count number of returned edges per point + num_children = np.zeros(len(cluster_points), dtype=np.intp) + for i, children in enumerate(children_map): + num_children[i] += len(children) + + # Create full edge list + full_parents = np.repeat( + np.arange(len(cluster_points), dtype=np.double), num_children + ) + full_children = in_cluster_ids[np.concatenate(children_map)] + full_distances = np.concatenate(distances_map) + + # Create output + mask = ( + (full_children != -1.0) + & (full_parents < full_children) + & (full_distances <= max_dist) + ) + edges = np.zeros((mask.sum(), 4), dtype=np.double) + edges[:, 0] = full_parents[mask] + edges[:, 1] = full_children[mask] + np.maximum( + np.maximum( + core_distances[edges[:, 0].astype(np.intp)], + core_distances[edges[:, 1].astype(np.intp)], + ), + full_distances[mask], + edges[:, 3], + ) + return edges + + +def _compute_branch_segmentation( + cluster_linkage_trees, + thread_pool, + min_branch_size=5, + allow_single_branch=False, + branch_selection_method="eom", + branch_selection_persistence=0.0, + max_branch_size=0, +): + """Extracts branches from the linkage hierarchies.""" + results = thread_pool( + delayed(_compute_branch_segmentation_of_cluster)( + cluster_linkage_tree, + min_branch_size=min_branch_size, + allow_single_branch=allow_single_branch, + branch_selection_method=branch_selection_method, + branch_selection_persistence=branch_selection_persistence, + max_branch_size=max_branch_size, + ) + for cluster_linkage_tree in cluster_linkage_trees + ) + if len(results): + return tuple(zip(*results)) + return (), (), (), () + + +def _compute_branch_segmentation_of_cluster( + cluster_linkage_tree, + min_branch_size=5, + allow_single_branch=False, + branch_selection_method="eom", + branch_selection_persistence=0.0, + max_branch_size=0, +): + """Select branches within one cluster.""" + condensed_tree = condense_tree(cluster_linkage_tree, min_branch_size) + if branch_selection_persistence > 0.0: + condensed_tree = simplify_branch_hierarchy( + condensed_tree, branch_selection_persistence + ) + stability = compute_stability(condensed_tree) + (labels, probabilities, persistences) = get_branches( + condensed_tree, + stability, + allow_single_branch=allow_single_branch, + branch_selection_method=branch_selection_method, + max_branch_size=max_branch_size, + ) + # Reset noise labels to k-cluster + labels[labels < 0] = len(persistences) + return (labels, probabilities, persistences, condensed_tree) + + +def _update_labelling( + cluster_labels, + cluster_probabilities, + cluster_points_, + cluster_centralities_, + branch_labels_, + branch_probabilities_, + branch_persistences_, + label_sides_as_branches=False, +): + """Updates the labelling with the detected branches.""" + # Allocate output + num_points = len(cluster_labels) + labels = -1 * np.ones(num_points, dtype=np.intp) + probabilities = cluster_probabilities.copy() + branch_labels = np.zeros(num_points, dtype=np.intp) + branch_probabilities = np.ones(num_points, dtype=np.double) + branch_centralities = np.zeros(num_points, dtype=np.double) + + # Compute the labels and probabilities + running_id = 0 + for _points, _centralities, _labels, _probs, _pers in zip( + cluster_points_, + cluster_centralities_, + branch_labels_, + branch_probabilities_, + branch_persistences_, + ): + num_branches = len(_pers) + branch_centralities[_points] = _centralities + if num_branches <= (1 if label_sides_as_branches else 2): + labels[_points] = running_id + running_id += 1 + else: + labels[_points] = _labels + running_id + branch_labels[_points] = _labels + branch_probabilities[_points] = _probs + probabilities[_points] += _probs + probabilities[_points] /= 2 + running_id += num_branches + 1 + + # Reorder other parts + return ( + labels, + probabilities, + branch_labels, + branch_probabilities, + branch_centralities, + ) + + +def _remap_edge_lists(edge_lists, internal_to_raw): + """ + Takes a list of edge lists and replaces the internal indices to raw indices. + + Parameters + ---------- + edge_lists : list[np.ndarray] + A list of numpy edgelists with the first two columns indicating + datapoints. + internal_to_raw: dict + A mapping from internal integer index to the raw integer index. + """ + for graph in edge_lists: + for edge in graph: + edge[0] = internal_to_raw[edge[0]] + edge[1] = internal_to_raw[edge[1]] + + +def _remap_point_lists(point_lists, internal_to_raw): + """ + Takes a list of points lists and replaces the internal indices to raw indices. + + Parameters + ---------- + point_lists : list[np.ndarray] + A list of numpy arrays with point indices. + internal_to_raw: dict + A mapping from internal integer index to the raw integer index. + """ + for points in point_lists: + for idx in range(len(points)): + points[idx] = internal_to_raw[points[idx]] + + +def _remap_labels(old_labels, finite_index, num_points): + """Creates new label array with infinite points set to -1.""" + new_labels = np.full(num_points, -1) + new_labels[finite_index] = old_labels + return new_labels + + +def _remap_probabilities(old_probs, finite_index, num_points): + """Creates new probability array with infinite points set to 0.""" + new_probs = np.zeros(num_points) + new_probs[finite_index] = old_probs + return new_probs + + +class BranchDetector(BaseEstimator, ClusterMixin): + """Performs a flare-detection post-processing step to detect branches within + clusters [1]_. + + For each cluster, a graph is constructed connecting the data points based on + their mutual reachability distances. Each edge is given a centrality value + based on how far it lies from the cluster's center. Then, the edges are + clustered as if that centrality was a distance, progressively removing the + 'center' of each cluster and seeing how many branches remain. + + Parameters + ---------- + min_branch_size : int, optional (default=None) + The minimum number of samples in a group for that group to be + considered a branch; groupings smaller than this size will seen as + points falling out of a branch. Defaults to the clusterer's min_cluster_size. + + allow_single_branch : bool, optional (default=False) + Analogous to ``allow_single_cluster``. + + branch_detection_method : str, optional (default=``full``) + Deteremines which graph is conctructed to detect branches with. Valid + values are, ordered by increasing computation cost and decreasing + sensitivity to noise: + - ``core``: Contains the edges that connect each point to all other + points within a mutual reachability distance lower than or equal to + the point's core distance. This is the cluster's subgraph of the + k-NN graph over the entire data set (with k = ``min_samples``). + - ``full``: Contains all edges between points in each cluster with a + mutual reachability distance lower than or equal to the distance of + the most-distance point in each cluster. These graphs represent the + 0-dimensional simplicial complex of each cluster at the first point in + the filtration where they contain all their points. + + branch_selection_method : str, optional (default='eom') + The method used to select branches from the cluster's condensed tree. + The standard approach for FLASC is to use the ``eom`` approach. + Options are: + * ``eom`` + * ``leaf`` + + branch_selection_persistence: float, optional (default=0.0) + An eccentricity persistence threshold. Branches with a persistence below + this value will be merged. See [3]_ for more information. Note that this + should not be used if we want to predict the cluster labels for new + points in future (e.g. using approximate_predict), as the + :func:`~flasc.prediction.approximate_predict` function is not aware of + this argument. + + max_branch_size : int, optional (default=0) + A limit to the size of clusters returned by the ``eom`` algorithm. + Has no effect when using ``leaf`` clustering (where clusters are + usually small regardless). Note that this should not be used if we + want to predict the cluster labels for new points in future (e.g. using + :func:`~flasc.prediction.approximate_predict`), as that function is + not aware of this argument. + + label_sides_as_branches : bool, optional (default=False), + When this flag is False, branches are only labelled for clusters with at + least three branches (i.e., at least y-shapes). Clusters with only two + branches represent l-shapes. The two branches describe the cluster's + outsides growing towards each other. Enableing this flag separates these + branches from each other in the produced labelling. + + Attributes + ---------- + labels_ : np.ndarray, shape (n_samples, ) + Labels that differentiate all subgroups (clusters and branches). Noisy + samples are given the label -1. + + probabilities_ : np.ndarray, shape (n_samples, ) + Probabilities considering both cluster and branch membership. Noisy + samples are assigned 0. + + branch_labels_ : np.ndarray, shape (n_samples, ) + Branch labels for each point. Noisy samples are given the label -1. + + branch_probabilities_ : np.ndarray, shape (n_samples, ) + Branch membership strengths for each point. Noisy samples are + assigned 0. + + branch_persistences_ : tuple (n_clusters) + A branch persistence (eccentricity range) for each detected branch. + + cluster_approximation_graphs_ : tuple (n_clusters) + The graphs used to detect branches in each cluster stored as a numpy + array with four columns: source, target, centrality, mutual reachability + distance. Points are labelled by their row-index into the input data. + The edges contained in the graphs depend on the ``branch_detection_method``: + - ``core``: Contains the edges that connect each point to all other + points in a cluster within a mutual reachability distance lower than + or equal to the point's core distance. This is an extension of the + minimum spanning tree introducing only edges with equal distances. The + reachability distance introduces ``num_points`` * ``min_samples`` of + such edges. + - ``full``: Contains all edges between points in each cluster with a + mutual reachability distance lower than or equal to the distance of + the most-distance point in each cluster. These graphs represent the + 0-dimensional simplicial complex of each cluster at the first point in + the filtration where they contain all their points. + + cluster_condensed_trees_ : tuple (n_clusters) + A condensed branch hierarchy for each cluster produced during the + branch detection step. Data points are numbered with in-cluster ids. + + cluster_linkage_trees_ : tuple (n_clusters) + A single linkage tree for each cluster produced during the branch + detection step, in the scipy hierarchical clustering format. + (see http://docs.scipy.org/doc/scipy/reference/cluster.hierarchy.html). + Data points are numbered with in-cluster ids. + + cluster_centralities_ : np.ndarray, shape (n_samples, ) + Centrality values for each point in a cluster. Overemphasizes points' + eccentricity within the cluster as the values are based on minimum + spanning trees that do not contain the equally distanced edges resulting + from the mutual reachability distance. + + cluster_points_ : list (n_clusters) + The data point row indices for each cluster. + + References + ---------- + .. [1] Bot, D. M., Peeters, J., Liesenborgs J., & Aerts, J. (2023, November). + FLASC: A Flare-Sensitive Clustering Algorithm: Extending HDBSCAN* for + Detecting Branches in Clusters. arXiv:2311.15887 + """ + + def __init__( + self, + min_branch_size=None, + allow_single_branch=False, + branch_detection_method="full", + branch_selection_method="eom", + branch_selection_persistence=0.0, + max_branch_size=0, + label_sides_as_branches=False, + ): + self.min_branch_size = min_branch_size + self.allow_single_branch = allow_single_branch + self.branch_detection_method = branch_detection_method + self.branch_selection_method = branch_selection_method + self.branch_selection_persistence = branch_selection_persistence + self.max_branch_size = max_branch_size + self.label_sides_as_branches = label_sides_as_branches + + self._cluster_approximation_graphs = None + self._cluster_condensed_trees = None + self._cluster_linkage_trees = None + self._branch_exemplars = None + + def fit(self, X, y=None): + """ + Perform a flare-detection post-processing step to detect branches within + clusters. + + Parameters + ---------- + X : HDBSCAN + A fitted HDBSCAN object with branch detection data generated. + + Returns + ------- + self : object + Returns self. + """ + self._clusterer = X + kwargs = self.get_params() + ( + self.labels_, + self.probabilities_, + self.branch_labels_, + self.branch_probabilities_, + self.branch_persistences_, + self._cluster_approximation_graphs, + self._cluster_condensed_trees, + self._cluster_linkage_trees, + self.cluster_centralities_, + self.cluster_points_, + ) = detect_branches_in_clusters(X, **kwargs) + + return self + + def fit_predict(self, X, y=None): + """ + Perform a flare-detection post-processing step to detect branches within + clusters [1]_. + + Parameters + ---------- + X : HDBSCAN + A fitted HDBSCAN object with branch detection data generated. + + Returns + ------- + labels : ndarray, shape (n_samples, ) + subgroup labels differentiated by cluster and branch. + """ + self.fit(X, y) + return self.labels_ + + def weighted_centroid(self, label_id, data=None): + """Provides an approximate representative point for a given branch. + Note that this technique assumes a euclidean metric for speed of + computation. For more general metrics use the ``weighted_medoid`` method + which is slower, but can work with the metric the model trained with. + + Parameters + ---------- + label_id: int + The id of the cluster to compute a centroid for. + + data : np.ndarray (n_samples, n_features), optional (default=None) + A dataset to use instead of the raw data that was clustered on. + + Returns + ------- + centroid: array of shape (n_features,) + A representative centroid for cluster ``label_id``. + """ + if self.labels_ is None: + raise AttributeError("Model has not been fit to data") + if self._clusterer._raw_data is None and data is None: + raise AttributeError("Raw data not available") + if label_id == -1: + raise ValueError( + "Cannot calculate weighted centroid for -1 cluster " + "since it is a noise cluster" + ) + if data is None: + data = self._clusterer._raw_data + mask = self.labels_ == label_id + cluster_data = data[mask] + cluster_membership_strengths = self.probabilities_[mask] + + return np.average(cluster_data, weights=cluster_membership_strengths, axis=0) + + def weighted_medoid(self, label_id, data=None): + """Provides an approximate representative point for a given branch. + + Note that this technique can be very slow and memory intensive for large + clusters. For faster results use the ``weighted_centroid`` method which + is faster, but assumes a euclidean metric. + + Parameters + ---------- + label_id: int + The id of the cluster to compute a medoid for. + + data : np.ndarray (n_samples, n_features), optional (default=None) + A dataset to use instead of the raw data that was clustered on. + + Returns + ------- + centroid: array of shape (n_features,) + A representative medoid for cluster ``label_id``. + """ + if self.labels_ is None: + raise AttributeError("Model has not been fit to data") + if self._clusterer._raw_data is None and data is None: + raise AttributeError("Raw data not available") + if label_id == -1: + raise ValueError( + "Cannot calculate weighted centroid for -1 cluster " + "since it is a noise cluster" + ) + if data is None: + data = self._clusterer._raw_data + mask = self.labels_ == label_id + cluster_data = data[mask] + cluster_membership_strengths = self.probabilities_[mask] + + dist_metric = self._clusterer.branch_detection_data_.dist_metric + dist_mat = dist_metric.pairwise(cluster_data) * cluster_membership_strengths + medoid_index = np.argmin(dist_mat.sum(axis=1)) + return cluster_data[medoid_index] + + @property + def cluster_approximation_graph_(self): + """See :class:`~hdbscan.branches.BranchDetector` for documentation.""" + if self._cluster_approximation_graphs is None: + raise AttributeError( + "No cluster approximation graph was generated; try running fit first." + ) + return ApproximationGraph( + self._cluster_approximation_graphs, + self.labels_, + self.probabilities_, + self._clusterer.labels_, + self._clusterer.probabilities_, + self.cluster_centralities_, + self.branch_labels_, + self.branch_probabilities_, + self._clusterer._raw_data, + ) + + @property + def cluster_condensed_trees_(self): + """See :class:`~hdbscan.branches.BranchDetector` for documentation.""" + if self._cluster_condensed_trees is None: + raise AttributeError( + "No cluster condensed trees were generated; try running fit first." + ) + return [ + CondensedTree(tree, self.branch_selection_method, self.allow_single_branch) + for tree in self._cluster_condensed_trees + ] + + @property + def cluster_linkage_trees_(self): + """See :class:`~hdbscan.branches.BranchDetector` for documentation.""" + if self._cluster_linkage_trees is None: + raise AttributeError( + "No cluster linkage trees were generated; try running fit first." + ) + return [SingleLinkageTree(tree) for tree in self._cluster_linkage_trees] + + @property + def branch_exemplars_(self): + """See :class:`~hdbscan.branches.BranchDetector` for documentation.""" + if self._branch_exemplars is not None: + return self._branch_exemplars + if self._clusterer._raw_data is None: + raise AttributeError( + "Branch exemplars not available with precomputed " "distances." + ) + if self._cluster_condensed_trees is None: + raise AttributeError("No branches detected; try running fit first.") + + num_clusters = len(self._cluster_condensed_trees) + branch_cluster_trees = [ + branch_tree[branch_tree["child_size"] > 1] + for branch_tree in self._cluster_condensed_trees + ] + selected_branch_ids = [ + sorted(branch_tree._select_clusters()) + for branch_tree in self.cluster_condensed_trees_ + ] + + self._branch_exemplars = [None] * num_clusters + + for i, points in enumerate(self.cluster_points_): + selected_branches = selected_branch_ids[i] + if len(selected_branches) <= (1 if self.label_sides_as_branches else 2): + continue + + self._branch_exemplars[i] = [] + raw_condensed_tree = self._cluster_condensed_trees[i] + + for branch in selected_branches: + _branch_exemplars = np.array([], dtype=np.intp) + for leaf in recurse_leaf_dfs(branch_cluster_trees[i], np.intp(branch)): + leaf_max_lambda = raw_condensed_tree["lambda_val"][ + raw_condensed_tree["parent"] == leaf + ].max() + candidates = raw_condensed_tree["child"][ + (raw_condensed_tree["parent"] == leaf) + & (raw_condensed_tree["lambda_val"] == leaf_max_lambda) + ] + _branch_exemplars = np.hstack([_branch_exemplars, candidates]) + ids = points[_branch_exemplars] + self._branch_exemplars[i].append(self._clusterer._raw_data[ids, :]) + + return self._branch_exemplars + + +def approximate_predict_branch(branch_detector, points_to_predict): + """Predict the cluster and branch label of new points. + + Extends ``approximate_predict`` to also predict in which branch + new points lie (if the cluster they are part of has branches). + + Parameters + ---------- + branch_detector : BranchDetector + A clustering object that has been fit to vector inpt data. + + points_to_predict : array, or array-like (n_samples, n_features) + The new data points to predict cluster labels for. They should + have the same dimensionality as the original dataset over which + clusterer was fit. + + Returns + ------- + labels : array (n_samples,) + The predicted cluster and branch labels. + + probabilities : array (n_samples,) + The soft cluster scores for each. + + cluster_labels : array (n_samples,) + The predicted cluster labels. + + cluster_probabilities : array (n_samples,) + The soft cluster scores for each. + + branch_labels : array (n_samples,) + The predicted cluster labels. + + branch_probabilities : array (n_samples,) + The soft cluster scores for each. + """ + + cluster_labels, cluster_probabilities, connecting_points = approximate_predict( + branch_detector._clusterer, points_to_predict, return_connecting_points=True + ) + + num_predict = len(points_to_predict) + labels = np.empty(num_predict, dtype=np.intp) + probabilities = np.zeros(num_predict, dtype=np.double) + branch_labels = np.zeros(num_predict, dtype=np.intp) + branch_probabilities = np.ones(num_predict, dtype=np.double) + + min_num_branches = 2 if not branch_detector.label_sides_as_branches else 1 + for i, (label, prob, connecting_point) in enumerate( + zip(cluster_labels, cluster_probabilities, connecting_points) + ): + if label < 0: + labels[i] = -1 + elif len(branch_detector.branch_persistences_[label]) <= min_num_branches: + labels[i] = label + probabilities[i] = prob + else: + labels[i] = branch_detector.labels_[connecting_point] + branch_labels[i] = branch_detector.branch_labels_[connecting_point] + branch_probabilities[i] = branch_detector.branch_probabilities_[ + connecting_point + ] + probabilities[i] = (prob + branch_probabilities[i]) / 2 + return ( + labels, + probabilities, + cluster_labels, + cluster_probabilities, + branch_labels, + branch_probabilities, + ) + + +class SequentialPool: + """API of a Joblib Parallel pool but sequential execution""" + + def __init__(self): + self.n_jobs = 1 + + def __call__(self, jobs): + return [fun(*args, **kwargs) for (fun, args, kwargs) in jobs] diff --git a/hdbscan/flat.py b/hdbscan/flat.py index e5912266..fa84806d 100644 --- a/hdbscan/flat.py +++ b/hdbscan/flat.py @@ -340,7 +340,7 @@ def approximate_predict_flat(clusterer, k=2 * min_samples) for i in range(points_to_predict.shape[0]): - label, prob = _find_cluster_and_probability( + label, prob, neighbors = _find_cluster_and_probability( condensed_tree, prediction_data.cluster_tree, neighbor_indices[i], diff --git a/hdbscan/hdbscan_.py b/hdbscan/hdbscan_.py index c87b69d9..290b47fa 100644 --- a/hdbscan/hdbscan_.py +++ b/hdbscan/hdbscan_.py @@ -36,6 +36,7 @@ from .plots import CondensedTree, SingleLinkageTree, MinimumSpanningTree from .prediction import PredictionData +from .branches import BranchDetectionData KDTREE_VALID_METRICS = ["euclidean", "l2", "minkowski", "p", "manhattan", "cityblock", "l1", "chebyshev", "infinity"] BALLTREE_VALID_METRICS = KDTREE_VALID_METRICS + [ @@ -996,6 +997,11 @@ class HDBSCAN(BaseEstimator, ClusterMixin): to set this to True. (default False) + branch_detection_data : boolean, optional + Whether to generated extra cached data for detecting branch- + hierarchies within clusters. If you wish to use functions from + ``hdbscan.branches`` set this to True. (default False) + match_reference_implementation : bool, optional (default=False) There exist some interpretational differences between this HDBSCAN* implementation and the original authors reference @@ -1053,6 +1059,10 @@ class HDBSCAN(BaseEstimator, ClusterMixin): :func:`~hdbscan.prediction.membership_vector`, and :func:`~hdbscan.prediction.all_points_membership_vectors`). + branch_detection_data_ : BranchDetectionData object + Cached data used for detecting branch-hierarchies within clusters. + Neccessary only if you are using funcotin from ``hdbscan.branches``. + exemplars_ : list A list of exemplar points for clusters. Since HDBSCAN supports arbitrary shapes for clusters we cannot provide a single cluster @@ -1115,6 +1125,7 @@ def __init__( cluster_selection_method="eom", allow_single_cluster=False, prediction_data=False, + branch_detection_data=False, match_reference_implementation=False, **kwargs ): @@ -1135,6 +1146,7 @@ def __init__( self.allow_single_cluster = allow_single_cluster self.match_reference_implementation = match_reference_implementation self.prediction_data = prediction_data + self.branch_detection_data = branch_detection_data self._metric_kwargs = kwargs @@ -1144,6 +1156,8 @@ def __init__( self._raw_data = None self._outlier_scores = None self._prediction_data = None + self._finite_index = None + self._branch_detection_data = None self._relative_validity = None def fit(self, X, y=None): @@ -1171,12 +1185,12 @@ def fit(self, X, y=None): if ~self._all_finite: # Pass only the purely finite indices into hdbscan # We will later assign all non-finite points to the background -1 cluster - finite_index = get_finite_row_indices(X) - clean_data = X[finite_index] + self._finite_index = get_finite_row_indices(X) + clean_data = X[self._finite_index] internal_to_raw = { - x: y for x, y in zip(range(len(finite_index)), finite_index) + x: y for x, y in zip(range(len(self._finite_index)), self._finite_index) } - outliers = list(set(range(X.shape[0])) - set(finite_index)) + outliers = list(set(range(X.shape[0])) - set(self._finite_index)) else: clean_data = X elif issparse(X): @@ -1193,7 +1207,9 @@ def fit(self, X, y=None): # prediction data only applies to the persistent model, so remove # it from the keyword args we pass on the the function kwargs.pop("prediction_data", None) + kwargs.pop("branch_detection_data", None) kwargs.update(self._metric_kwargs) + kwargs['gen_min_span_tree'] |= self.branch_detection_data ( self.labels_, @@ -1213,15 +1229,17 @@ def fit(self, X, y=None): self._single_linkage_tree, internal_to_raw, outliers ) new_labels = np.full(X.shape[0], -1) - new_labels[finite_index] = self.labels_ + new_labels[self._finite_index] = self.labels_ self.labels_ = new_labels new_probabilities = np.zeros(X.shape[0]) - new_probabilities[finite_index] = self.probabilities_ + new_probabilities[self._finite_index] = self.probabilities_ self.probabilities_ = new_probabilities if self.prediction_data: self.generate_prediction_data() + if self.branch_detection_data: + self.generate_branch_detection_data() return self @@ -1275,6 +1293,38 @@ def generate_prediction_data(self): "than mere distances is required!" ) + def generate_branch_detection_data(self): + """ + Create data that caches intermediate results used for detecting + branches within clusters. This data is only useful if you are + intending to use functions from ``hdbscan.branches``. + """ + if self.metric in FAST_METRICS: + min_samples = self.min_samples or self.min_cluster_size + if self.metric in KDTREE_VALID_METRICS: + tree_type = "kdtree" + elif self.metric in BALLTREE_VALID_METRICS: + tree_type = "balltree" + else: + warn("Metric {} not supported for branch detection!".format(self.metric)) + return + + self._branch_detection_data = BranchDetectionData( + self._raw_data, + self._all_finite, + None if self._all_finite else self._finite_index, + self.labels_, + min_samples, + tree_type=tree_type, + metric=self.metric, + **self._metric_kwargs + ) + else: + warn( + "Branch detection for non-vector space inputs is not (yet)" + " implemented." + ) + def weighted_cluster_centroid(self, cluster_id): """Provide an approximate representative point for a given cluster. Note that this technique assumes a euclidean metric for speed of @@ -1385,6 +1435,13 @@ def prediction_data_(self): else: return self._prediction_data + @property + def branch_detection_data_(self): + if self._branch_detection_data is None: + raise AttributeError("No branch detection data was generated") + else: + return self._branch_detection_data + @property def outlier_scores_(self): if self._outlier_scores is not None: diff --git a/hdbscan/plots.py b/hdbscan/plots.py index 617721e5..1328aceb 100644 --- a/hdbscan/plots.py +++ b/hdbscan/plots.py @@ -898,3 +898,413 @@ def to_networkx(self): set_node_attributes(result, data_dict, 'data') return result + + +class ApproximationGraph: + """ + Cluster approximation graph describing the connectivity in clusters + that is used to detect branches. + + Parameters + ---------- + approximation_graphs : list[np.ndarray], shape (n_clusters), + + labels : np.ndarray, shape (n_samples, ) + cluster and branches labelling. + + probabilities : np.ndarray, shape (n_samples, ) + cluster and branches probabilities. + + cluster_labels : np.ndarray, shape (n_samples, ) + HDBSCAN* labelling. + + cluster_probabilities : np.ndarray, shape (n_samples, ) + HDBSCAN* probabilities. + + cluster_centralities : np.ndarray, shape (n_samples, ) + Within cluster centrality values. + + branch_labels : np.ndarray, shape (n_samples, ) + Within cluster branch labels for each point. + + branch_probabilities : np.ndarray, shape (n_samples, ) + Within cluster branch membership strengths for each point. + + Attributes + ---------- + point_mask : np.ndarray[bool], shape (n_samples) + A mask to extract points within clusters from the raw data. + """ + + def __init__( + self, + approximation_graphs, + labels, + probabilities, + cluster_labels, + cluster_probabilities, + cluster_centralities, + branch_labels, + branch_probabilities, + raw_data=None, + ): + self._edges = np.core.records.fromarrays( + np.hstack( + ( + np.concatenate(approximation_graphs), + np.repeat( + np.arange(len(approximation_graphs)), + [g.shape[0] for g in approximation_graphs], + )[None].T, + ) + ).transpose(), + names="parent, child, centrality, mutual_reachability, cluster", + formats="intp, intp, double, double, intp", + ) + self.point_mask = cluster_labels >= 0 + self._raw_data = raw_data[self.point_mask, :] if raw_data is not None else None + self._points = np.core.records.fromarrays( + np.vstack( + ( + np.where(self.point_mask)[0], + labels[self.point_mask], + probabilities[self.point_mask], + cluster_labels[self.point_mask], + cluster_probabilities[self.point_mask], + cluster_centralities[self.point_mask], + branch_labels[self.point_mask], + branch_probabilities[self.point_mask], + ) + ), + names="id, label, probability, cluster_label, cluster_probability, cluster_centrality, branch_label, branch_probability", + formats="intp, intp, double, intp, double, double, intp, double", + ) + self._pos = None + + def plot( + self, + positions=None, + feature_names=None, + node_color="label", + node_vmin=None, + node_vmax=None, + node_cmap="viridis", + node_alpha=1, + # node_desat=None, + node_size=1, + node_marker="o", + edge_color="k", + edge_vmin=None, + edge_vmax=None, + edge_cmap="viridis", + edge_alpha=1, + edge_width=1, + ): + """ + Plots the Approximation graph, requires networkx and matplotlib. + + Parameters + ---------- + positions : np.ndarray, shape (n_samples, 2) (default = None) + A position for each data point in the graph or each data point in the + raw data. When None, the function attempts to compute graphviz' + sfdp layout, which requires pygraphviz to be installed and available. + + node_color : str (default = 'label') + The point attribute to to color the nodes by. Possible values: + - id + - label + - probability + - cluster_label + - cluster_probability + - cluster_centrality + - branch_label + - branch_probability, + - The input data's feature (if available) names if + ``feature_names`` is specified or ``feature_x`` for the x-th feature + if no ``feature_names`` are given, or anything matplotlib scatter + interprets as a color. + + node_vmin : float, (default = None) + The minimum value to use for normalizing node colors. + + node_vmax : float, (default = None) + The maximum value to use for normalizing node colors. + + node_cmap : str, (default = 'tab10') + The cmap to use for coloring nodes. + + node_alpha : float, (default = 1) + The node transparency value. + + node_size : float, (default = 5) + The node marker size value. + + node_marker : str, (default = 'o') + The node marker string. + + edge_color : str (default = 'label') + The point attribute to to color the nodes by. Possible values: + - weight + - mutual reachability + - centrality, + - cluster, + or anything matplotlib linecollection interprets as color. + + edge_vmin : float, (default = None) + The minimum value to use for normalizing edge colors. + + edge_vmax : float, (default = None) + The maximum value to use for normalizing edge colors. + + edge_cmap : str, (default = viridis) + The cmap to use for coloring edges. + + edge_alpha : float, (default = 1) + The edge transparency value. + + edge_width : float, (default = 1) + The edge line width size value. + """ + try: + import matplotlib.pyplot as plt + import matplotlib.collections as mc + except ImportError: + raise ImportError( + "You must install the matplotlib library to plot the Approximation Graph." + ) + + # Extract node color data + if node_color is None: + pass + elif isinstance(node_color, str): + if node_color in self._points.dtype.names: + if "label" in node_color: + node_vmax = 9 + node_vmin = 0 + node_cmap = "tab10" + node_color = self._points[node_color] % 10 + else: + node_color = self._points[node_color] + elif ( + self._raw_data is not None + and feature_names is not None + and node_color in feature_names + ): + idx = feature_names.index(node_color) + node_color = self._raw_data[:, idx] + elif self._raw_data is not None and node_color.startswith("feature_"): + idx = int(node_color[8:]) + node_color = self._raw_data[:, idx] + elif len(node_color) == len(self.point_mask): + node_color = node_color[self.point_mask] + + # Extract edge color data + if isinstance(edge_color, str) and edge_color in self._edges.dtype.names: + edge_color = self._edges[edge_color] + + # Compute or extract layout + self._xs = np.nan * np.ones(len(self.point_mask)) + self._ys = np.nan * np.ones(len(self.point_mask)) + if positions is None: + try: + import networkx as nx + except ImportError: + raise ImportError( + "You must install the networkx to compute a sfdp layout." + ) + if self._pos is None: + g = nx.Graph() + for row in self._edges: + g.add_edge( + row["parent"], + row["child"], + weight=1 / row["mutual_reachability"], + ) + self._pos = nx.nx_agraph.graphviz_layout(g, prog="sfdp") + for k, v in self._pos.items(): + self._xs[k] = v[0] + self._ys[k] = v[1] + else: + if positions.shape[0] == len(self.point_mask): + self._xs = positions[:, 0] + self._ys = positions[:, 1] + elif positions.shape[0] == len(self._points): + for i, d in enumerate(self._points["id"]): + self._xs[d, 0] = positions[i, 0] + self._ys[d, 1] = positions[i, 1] + else: + raise ValueError("Incorrect number of positions specified.") + source = self._edges["parent"] + target = self._edges["child"] + lc = mc.LineCollection( + list( + zip( + zip(self._xs[source], self._ys[source]), + zip(self._xs[target], self._ys[target]), + ) + ), + alpha=edge_alpha, + cmap=edge_cmap, + linewidths=edge_width, + zorder=0, + ) + lc.set_clim(edge_vmin, edge_vmax) + if isinstance(edge_color, str): + lc.set_edgecolor(edge_color) + else: + lc.set_array(edge_color) + if edge_alpha is not None: + lc.set_alpha(edge_alpha) + plt.gca().add_collection(lc) + plt.scatter( + self._xs[~self.point_mask], + self._ys[~self.point_mask], + node_size, + color='silver', + marker=node_marker, + alpha=node_alpha, + linewidth=0, + edgecolor='none', + ) + plt.scatter( + self._xs[self.point_mask], + self._ys[self.point_mask], + node_size, + node_color, + cmap=node_cmap, + marker=node_marker, + alpha=node_alpha, + linewidth=0, + edgecolor='none', + vmin=node_vmin, + vmax=node_vmax, + ) + plt.axis("off") + + def to_numpy(self): + """Converts the approximation graph to numpy arrays. + + Returns + ------- + points : np.recarray, shape (n_points, 8) + A numpy record array with for each point its: + - id (row index), + - label, + - probability, + - cluster label, + - cluster probability, + - cluster centrality, + - branch label, + - branch probability + + edges : np.recarray, shape (n_edges, 5) + A numpy record array with for each edge its: + - parent point, + - child point, + - cluster centrality, + - mutual reachability, + - cluster label + """ + return self._points.copy(), self._edges.copy() + + def to_pandas(self): + """Converts the approximation graph to pandas data frames. + + Returns + ------- + points : pd.DataFrame, shape (n_points, 8) + A DataFrame with for each point its: + - id (row index), + - label, + - probability, + - cluster label, + - cluster probability, + - cluster centrality, + - branch label, + - branch probability + + edges : pd.DataFrame, shape (n_edges, 5) + A DataFrame with for each edge its: + - parent point, + - child point, + - cluster centrality, + - mutual reachability, + - cluster label + """ + try: + from pandas import DataFrame + except ImportError: + raise ImportError( + "You must have pandas installed to export pandas DataFrames" + ) + + points = DataFrame(self._points) + edges = DataFrame(self._edges) + return points, edges + + def to_networkx(self, feature_names=None): + """Convert to a NetworkX Graph object. + + Parameters + ---------- + feature_names : list[n_features] + Names to use for the data features if available. + + Returns + ------- + g : nx.Graph + A NetworkX Graph object containing the non-noise points and edges + within clusters. + + Node attributes: + - label, + - probability, + - cluster label, + - cluster probability, + - cluster centrality, + - branch label, + - branch probability, + + Edge attributes: + - weight (1 / mutual_reachability), + - mutual_reachability, + - centrality, + - cluster label, + - + """ + try: + import networkx as nx + except ImportError: + raise ImportError( + "You must have networkx installed to export networkx graphs" + ) + + g = nx.Graph() + # Add edges + for row in self._edges: + g.add_edge( + row["parent"], + row["child"], + weight=1 / row["mutual_reachability"], + mutual_reachability=row["mutual_reachability"], + centrality=row["centrality"], + cluster=row["cluster"], + ) + + # Add FLASC features + for attr in self._points.dtype.names[1:]: + nx.set_node_attributes(g, dict(self._points[["id", attr]]), attr) + + # Add raw data features + if self._raw_data is not None: + if feature_names is None: + feature_names = [f"feature {i}" for i in range(self._raw_data.shape[1])] + for idx, name in enumerate(feature_names): + nx.set_node_attributes( + g, + dict(zip(self._points["id"], self._raw_data[:, idx])), + name, + ) + + return g \ No newline at end of file diff --git a/hdbscan/prediction.py b/hdbscan/prediction.py index 10cd6c60..b5b1fc52 100644 --- a/hdbscan/prediction.py +++ b/hdbscan/prediction.py @@ -325,10 +325,10 @@ def _find_cluster_and_probability(tree, cluster_tree, neighbor_indices, else: prob = 0.0 - return cluster_label, prob + return cluster_label, prob, nearest_neighbor -def approximate_predict(clusterer, points_to_predict): +def approximate_predict(clusterer, points_to_predict, return_connecting_points=False): """Predict the cluster label of new points. The returned labels will be those of the original clustering found by ``clusterer``, and therefore are not (necessarily) the cluster labels that would @@ -352,6 +352,10 @@ def approximate_predict(clusterer, points_to_predict): The new data points to predict cluster labels for. They should have the same dimensionality as the original dataset over which clusterer was fit. + + return_connecting_points : bool, optional + Whether to return the index of the nearest neighbor in the original + dataset for each of the ``points_to_predict``. Default is False Returns ------- @@ -361,6 +365,11 @@ def approximate_predict(clusterer, points_to_predict): probabilities : array (n_samples,) The soft cluster scores for each of the ``points_to_predict`` + neighbors : array (n_samples,) + The index of the nearest neighbor in the original dataset for each + of the ``points_to_predict``. Only returned if + ``return_connecting_points=True``. + See Also -------- :py:func:`hdbscan.predict.membership_vector` @@ -383,10 +392,15 @@ def approximate_predict(clusterer, points_to_predict): ' will be automatically predicted as noise.') labels = -1 * np.ones(points_to_predict.shape[0], dtype=np.int32) probabilities = np.zeros(points_to_predict.shape[0], dtype=np.float32) + if return_connecting_points: + neighbors = -1 * np.ones(points_to_predict.shape[0], dtype=np.int32) + return labels, probabilities, neighbors return labels, probabilities labels = np.empty(points_to_predict.shape[0], dtype=np.int32) probabilities = np.empty(points_to_predict.shape[0], dtype=np.float64) + if return_connecting_points: + neighbors = np.empty(points_to_predict.shape[0], dtype=np.int32) min_samples = clusterer.min_samples or clusterer.min_cluster_size neighbor_distances, neighbor_indices = \ @@ -394,7 +408,7 @@ def approximate_predict(clusterer, points_to_predict): k=2 * min_samples) for i in range(points_to_predict.shape[0]): - label, prob = _find_cluster_and_probability( + label, prob, neighbor = _find_cluster_and_probability( clusterer.condensed_tree_, clusterer.prediction_data_.cluster_tree, neighbor_indices[i], @@ -406,7 +420,11 @@ def approximate_predict(clusterer, points_to_predict): ) labels[i] = label probabilities[i] = prob + if return_connecting_points: + neighbors[i] = neighbor + if return_connecting_points: + return labels, probabilities, neighbors return labels, probabilities diff --git a/hdbscan/tests/test_branches.py b/hdbscan/tests/test_branches.py new file mode 100644 index 00000000..5a6d9a36 --- /dev/null +++ b/hdbscan/tests/test_branches.py @@ -0,0 +1,474 @@ +import numpy as np +from scipy import stats +from scipy import sparse +from scipy.spatial import distance +from sklearn.utils._testing import assert_raises +from sklearn.utils.estimator_checks import check_estimator +from hdbscan import ( + HDBSCAN, + BranchDetector, + detect_branches_in_clusters, + approximate_predict_branch, +) +from hdbscan.tests.test_hdbscan import ( + if_matplotlib, + if_networkx, + if_pandas, +) + +from sklearn.utils import check_random_state, shuffle as util_shuffle +from sklearn.datasets import make_blobs +from sklearn.preprocessing import StandardScaler + +from tempfile import mkdtemp +from functools import wraps +import numbers +import pytest + +import warnings + + +def if_pygraphviz(func): + """Test decorator that skips test if networkx or pygraphviz is not installed.""" + + @wraps(func) + def run_test(*args, **kwargs): + try: + import networkx + import pygraphviz + except ImportError: + pytest.skip("NetworkX or pygraphviz not available.") + else: + return func(*args, **kwargs) + + return run_test + + +def make_branches(n_samples=100, shuffle=True, noise=None, random_state=None): + if isinstance(n_samples, numbers.Integral): + n_samples_out = n_samples // 3 + n_samples_in = n_samples - n_samples_out + else: + try: + n_samples_out, n_samples_in = n_samples + except ValueError as e: + raise ValueError( + "`n_samples` can be either an int or a two-element tuple." + ) from e + + generator = check_random_state(random_state) + + outer_circ_x = np.cos(np.linspace(np.pi / 2, np.pi, n_samples_out)) + outer_circ_y = np.sin(np.linspace(np.pi / 2, np.pi, n_samples_out)) - 1 + inner_circ_x = np.cos(np.linspace(0, np.pi, n_samples_in)) + inner_circ_y = 1 - np.sin(np.linspace(0, np.pi, n_samples_in)) + + X = np.vstack( + [ + np.append(outer_circ_x, inner_circ_x), + np.append(outer_circ_y, inner_circ_y), + ] + ).T + y = np.hstack( + [ + np.zeros(n_samples_out, dtype=np.intp), + np.ones(n_samples_in, dtype=np.intp), + ] + ) + + if shuffle: + X, y = util_shuffle(X, y, random_state=generator) + + if noise is not None: + X += generator.normal(scale=noise, size=X.shape) + + return X, y + + +def generate_noisy_data(): + blobs, yBlobs = make_blobs( + n_samples=50, + centers=[(-0.75, 2.25), (2.0, -0.5)], + cluster_std=0.2, + random_state=3, + ) + moons, _ = make_branches(n_samples=150, noise=0.06, random_state=3) + yMoons = np.full(moons.shape[0], 2) + np.random.seed(5) + noise = np.random.uniform(-1.0, 3.0, (50, 2)) + yNoise = np.full(50, -1) + return ( + np.vstack((blobs, moons, noise)), + np.concatenate((yBlobs, yMoons, yNoise)), + ) + + +X, y = generate_noisy_data() +X = StandardScaler().fit_transform(X) + +X_missing_data = X.copy() +X_missing_data[0] = [np.nan, 1] +X_missing_data[5] = [np.nan, np.nan] + +# --- Branch Detection Data + + +def test_branch_detection_data(): + """Check that the flag generates internal branch_detection_data.""" + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + branch_data = c.branch_detection_data_ + assert c.minimum_spanning_tree_ is not None + assert branch_data.all_finite == True + assert branch_data.core_distances.shape[0] == X.shape[0] + assert branch_data.neighbors.shape[0] == X.shape[0] + assert branch_data.neighbors.shape[1] == c.min_samples or c.min_cluster_size + assert branch_data.finite_index is None + + +def test_branch_detection_data_with_missing(): + """Check internal branch_detection_data recognizes missing data.""" + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X_missing_data) + branch_data = c.branch_detection_data_ + assert c.minimum_spanning_tree_ is not None + assert branch_data.all_finite == False + assert branch_data.core_distances.shape[0] == X.shape[0] - 2 + assert branch_data.neighbors.shape[0] == X.shape[0] - 2 + assert branch_data.neighbors.shape[1] == c.min_samples or c.min_cluster_size + assert branch_data.finite_index is not None + + +@pytest.mark.skip(reason="Unreachable code-branch cannot be tested.") +def test_branch_detection_data_with_non_tree_metric(): + """Check warning on unsupported metric.""" + with warnings.catch_warnings(record=True) as w: + # There are no fast metrics that are not supported by KDTree or BallTree! + # Cosine and arccoss both crash HDBSCAN. They go down the BallTree path, but + # the implementation does not support them. + c = HDBSCAN( + min_cluster_size=5, branch_detection_data=True, metric="cosine" + ).fit(X) + assert "Metric cosine not supported for branch detection!" in str(w[-1].message) + assert c.minimum_spanning_tree_ is not None + assert_raises(AttributeError, lambda: c.branch_detection_data) + + +def test_branch_detection_data_with_unsupported_input(): + """Check warning on unsupported inputs.""" + # Distance matrix + D = distance.squareform(distance.pdist(X)) + with warnings.catch_warnings(record=True) as w: + c = HDBSCAN( + min_cluster_size=5, metric="precomputed", branch_detection_data=True + ).fit(D) + assert ( + "Branch detection for non-vector space inputs is not (yet) implemented." + in str(w[-1].message) + ) + + # Sparse matrix + D /= np.max(D) + threshold = stats.scoreatpercentile(D.flatten(), 50) + D[D >= threshold] = 0.0 + D = sparse.csr_matrix(D) + D.eliminate_zeros() + with warnings.catch_warnings(record=True) as w: + c = HDBSCAN( + min_cluster_size=5, metric="precomputed", branch_detection_data=True + ).fit(D) + assert ( + "Branch detection for non-vector space inputs is not (yet) implemented." + in str(w[-1].message) + ) + + +def test_generate_branch_detection_data(): + """Generate branch detection data function does not re-generate MST.""" + c = HDBSCAN(min_cluster_size=5).fit(X) + c.generate_branch_detection_data() + assert c.branch_detection_data_ is not None + assert_raises(AttributeError, lambda: c.minimum_spanning_tree_) + + +# --- Detecting Branches + + +def check_detected_groups(c, n_clusters=3, n_branches=6): + """Checks branch_detector output for main invariants.""" + assert len(np.unique(c.labels_)) - int(-1 in c.labels_) == n_branches + noise_mask = c.labels_ == -1 + assert (c.branch_labels_[noise_mask] == 0).all() + assert (c.branch_probabilities_[noise_mask] == 1.0).all() + assert (c.probabilities_[noise_mask] == 0).all() + assert len(c.cluster_points_) == n_clusters + assert len(c.branch_persistences_) == n_clusters + assert sum(len(ps) for ps in c.branch_persistences_) >= (n_branches - n_clusters) + + +def test_branch_detector(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector( + branch_detection_method="core", branch_selection_method="eom" + ).fit(c) + check_detected_groups(b, n_branches=7) + + b = BranchDetector( + branch_detection_method="full", branch_selection_method="eom" + ).fit(c) + check_detected_groups(b) + + b = BranchDetector( + branch_detection_method="core", branch_selection_method="leaf" + ).fit(c) + check_detected_groups(b, n_branches=9) + + b = BranchDetector( + branch_detection_method="full", branch_selection_method="leaf" + ).fit(c) + check_detected_groups(b) + + +def test_min_branch_size(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector(min_branch_size=7).fit(c) + labels, counts = np.unique(b.labels_, return_counts=True) + assert (counts[labels >= 0] >= 7).all() + check_detected_groups(b) + + +def test_label_sides_as_branches(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector(label_sides_as_branches=True).fit(c) + check_detected_groups(b, n_branches=8) + + +def test_max_branch_size(): + """Suppresses one branch.""" + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector(label_sides_as_branches=True, max_branch_size=50).fit(c) + check_detected_groups(b, n_branches=7) + + +def test_allow_single_branch_with_persistence(): + # Generate single-cluster data + np.random.seed(0) + no_structure = np.random.rand(150, 2) + c = HDBSCAN( + min_samples=5, + min_cluster_size=150, + allow_single_cluster=True, + branch_detection_data=True, + ).fit(no_structure) + + # Without persistence, find 6 branches + b = BranchDetector( + min_branch_size=5, + branch_detection_method="core", + branch_selection_method="leaf", + ).fit(c) + unique_labels = np.unique(b.labels_) + assert len(unique_labels) == 6 + # Mac & Windows give 71, Linux gives 72. Probably different random values. + num_noise = np.sum(b.branch_probabilities_ == 0) + assert (num_noise == 71) | (num_noise == 72) + + # Adding presistence removes some branches + b = BranchDetector( + min_branch_size=5, + branch_detection_method="core", + branch_selection_method="leaf", + branch_selection_persistence=0.1, + ).fit(c) + unique_labels = np.unique(b.labels_) + assert len(unique_labels) == 1 + assert np.sum(b.branch_probabilities_ == 0) == 0 + + +def test_badargs(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + c_nofit = HDBSCAN(min_cluster_size=5, branch_detection_data=True) + c_nobranch = HDBSCAN(min_cluster_size=5, gen_min_span_tree=True).fit(X) + c_nomst = HDBSCAN(min_cluster_size=5).fit(X) + c_nomst.generate_branch_detection_data() + + assert_raises(AttributeError, detect_branches_in_clusters, "fail") + assert_raises(AttributeError, detect_branches_in_clusters, None) + assert_raises(AttributeError, detect_branches_in_clusters, "fail") + assert_raises(ValueError, detect_branches_in_clusters, c_nofit) + assert_raises(AttributeError, detect_branches_in_clusters, c_nobranch) + assert_raises(ValueError, detect_branches_in_clusters, c_nomst) + assert_raises(ValueError, detect_branches_in_clusters, c, min_branch_size=-1) + assert_raises(ValueError, detect_branches_in_clusters, c, min_branch_size=0) + assert_raises(ValueError, detect_branches_in_clusters, c, min_branch_size=1) + assert_raises(ValueError, detect_branches_in_clusters, c, min_branch_size=2.0) + assert_raises(ValueError, detect_branches_in_clusters, c, min_branch_size="fail") + assert_raises( + ValueError, detect_branches_in_clusters, c, branch_selection_persistence=-1 + ) + assert_raises( + ValueError, detect_branches_in_clusters, c, branch_selection_persistence=-0.1 + ) + assert_raises( + ValueError, + detect_branches_in_clusters, + c, + branch_selection_method="something_else", + ) + assert_raises( + ValueError, + detect_branches_in_clusters, + c, + branch_detection_method="something_else", + ) + + +# --- Branch Detector Functionality + + +def test_caching(): + cachedir = mkdtemp() + c = HDBSCAN(memory=cachedir, min_samples=5, branch_detection_data=True).fit(X) + b1 = BranchDetector().fit(c) + b2 = BranchDetector(allow_single_branch=True).fit(c) + n_groups1 = len(set(b1.labels_)) - int(-1 in b1.labels_) + n_groups2 = len(set(b2.labels_)) - int(-1 in b2.labels_) + assert n_groups1 == n_groups2 + + +def test_centroid_medoids(): + branch_centers = np.asarray( + [[-0.9, -1.0], [-0.9, 0.1], [-0.8, 1.9], [-0.5, 0.0], [1.7, -0.9]] + ) + + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + + centroids = np.asarray([b.weighted_centroid(i) for i in range(5)]) + rounded = np.around(np.asarray(centroids), decimals=1) + corder = np.lexsort((rounded[:, 1], rounded[:, 0])) + np.all(np.abs(centroids[corder, :] - branch_centers) < 0.1) + + medoids = np.asarray([b.weighted_medoid(i) for i in range(5)]) + rounded = np.around(np.asarray(medoids), decimals=1) + corder = np.lexsort((rounded[:, 1], rounded[:, 0])) + np.all(np.abs(medoids[corder, :] - branch_centers) < 0.1) + + +def test_exemplars(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + + branch_exemplars = b.branch_exemplars_ + assert branch_exemplars[0] is None + assert branch_exemplars[1] is None + assert len(branch_exemplars[2]) == 3 + assert len(b.branch_exemplars_) == 3 + + +def test_approximate_predict(): + c = HDBSCAN( + min_cluster_size=5, branch_detection_data=True, prediction_data=True + ).fit(X) + b = BranchDetector().fit(c) + + # A point on a branch (not noise) exact labels change per run + l, p, cl, cp, bl, bp = approximate_predict_branch(b, np.array([[-0.8, 0.0]])) + assert cl[0] > -1 + assert len(b.branch_persistences_[cl[0]]) > 2 + + # A point in a cluster + l, p, cl, cp, bl, bp = approximate_predict_branch(b, np.array([[-0.8, 2.0]])) + assert l[0] == cl[0] + assert bl[0] == 0 + assert bp[0] == 1.0 + + # A noise point + l, p, cl, cp, bl, bp = approximate_predict_branch(b, np.array([[1, 3.0]])) + assert l[0] == -1 + assert cl[0] == -1 + assert cp[0] == 0 + assert p[0] == 0.0 + assert cp[0] == 0.0 + assert bp[0] == 1.0 + + +# --- Attribute Output Formats + + +def test_trees_numpy_output_formats(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + points, edges = b.cluster_approximation_graph_.to_numpy() + assert points.shape[0] <= X.shape[0] # Excludes noise points + for t in b.cluster_condensed_trees_: + t.to_numpy() + for t in b.cluster_linkage_trees_: + t.to_numpy() + + +def test_trees_pandas_output_formats(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + if_pandas(b.cluster_approximation_graph_.to_pandas)() + for t in b.cluster_condensed_trees_: + if_pandas(t.to_pandas)() + for t in b.cluster_linkage_trees_: + if_pandas(t.to_pandas)() + + +def test_trees_networkx_output_formats(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + if_networkx(b.cluster_approximation_graph_.to_networkx)() + for t in b.cluster_condensed_trees_: + if_networkx(t.to_networkx)() + for t in b.cluster_linkage_trees_: + if_networkx(t.to_networkx)() + + +# --- Attribute plots + + +def test_condensed_tree_plot(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + for t in b.cluster_condensed_trees_: + if_matplotlib(t.plot)( + select_clusters=True, + label_clusters=True, + selection_palette=("r", "g", "b"), + cmap="Reds", + ) + if_matplotlib(t.plot)(log_size=True, colorbar=False, cmap="none") + + +def test_single_linkage_tree_plot(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + for t in b.cluster_linkage_trees_: + if_matplotlib(t.plot)(cmap="Reds") + if_matplotlib(t.plot)( + vary_line_width=False, + truncate_mode="lastp", + p=10, + cmap="none", + colorbar=False, + ) + + +def test_cluster_approximation_graph_plot(): + c = HDBSCAN(min_cluster_size=5, branch_detection_data=True).fit(X) + b = BranchDetector().fit(c) + g = b.cluster_approximation_graph_ + if_matplotlib(g.plot)(positions=X) + if_pygraphviz(if_matplotlib(g.plot))(node_color="x", feature_names=["x", "y"]) + if_pygraphviz(if_matplotlib(g.plot))(node_color=X[:, 0]) + if_pygraphviz(if_matplotlib(g.plot))(edge_color="centrality", node_alpha=0) + if_pygraphviz(if_matplotlib(g.plot))( + edge_color=g._edges["centrality"], node_alpha=0 + ) + + +@pytest.mark.skip(reason="need to refactor to meet newer standards") +def test_branch_detector_is_sklearn_estimator(): + check_estimator(BranchDetector) + diff --git a/notebooks/How to detect branches.ipynb b/notebooks/How to detect branches.ipynb new file mode 100644 index 00000000..219ae57a --- /dev/null +++ b/notebooks/How to detect branches.ipynb @@ -0,0 +1,538 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# How to detect banches in clusters\n", + "\n", + "HDBSCAN\\* is often used to find subpopulations in exploratory data analysis\n", + "workflows. Not only clusters themselves, but also their shape can represent\n", + "meaningful subpopulations. For example, a Y-shaped cluster may represent an\n", + "evolving process with two distinct end-states. Detecting these branches can\n", + "reveal interesting patterns that are not captured by density-based clustering.\n", + "\n", + "For example, HDBSCAN\\* finds 4 clusters in the datasets below, which does not\n", + "inform us of the branching structure:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from hdbscan import HDBSCAN, BranchDetector" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "def plot(labels):\n", + " \"\"\"Plots the data coloured by labels, with noise points in silver.\"\"\"\n", + " noise_mask = labels == -1\n", + " plt.scatter(data[noise_mask, 0], data[noise_mask, 1], 1, color=\"silver\")\n", + " plt.scatter(\n", + " data[~noise_mask, 0],\n", + " data[~noise_mask, 1],\n", + " 1,\n", + " labels[~noise_mask] % 10,\n", + " cmap=\"tab10\",\n", + " vmin=0,\n", + " vmax=9,\n", + " )\n", + " plt.axis(\"off\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Control points for line segments that merge three clusters\n", + "p0 = (0.13, -0.26)\n", + "p1 = (0.24, -0.12)\n", + "p2 = (0.32, 0.1)\n", + "\n", + "# Noisy points along lines between three clusters\n", + "segments = [\n", + " np.column_stack(\n", + " (np.linspace(p_start[0], p_end[0], 100), np.linspace(p_start[1], p_end[1], 100))\n", + " )\n", + " + np.random.normal(size=(100, 2), scale=0.01)\n", + " for p_start, p_end in [(p0, p1), (p1, p2)]\n", + "]\n", + "\n", + "# Original data with new segments\n", + "data = np.load(\"./clusterable_data.npy\")\n", + "data = np.concatenate((data, *segments))\n", + "\n", + "# HDBSCAN clusters\n", + "clusterer = HDBSCAN(min_cluster_size=15).fit(data)\n", + "plot(clusterer.labels_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, HDBSCAN\\*'s leaf clusters provide more detail. They segment the\n", + "points of different branches into distint clusters. However, the partitioning\n", + "and cluster hierarchy does not (necessarily) tell us how those clusters combine\n", + "into a larger shape." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "leaf_clusterer = HDBSCAN(min_cluster_size=15, cluster_selection_method='leaf').fit(data)\n", + "plot(leaf_clusterer.labels_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is where the branch detection post-processing step comes into play. The\n", + "functionality is described in detail by [Bot et\n", + "al](https://arxiv.org/abs/2311.15887). It operates on the detected clusters and\n", + "extracts a branch-hierarchy analogous to HDBSCAN*'s condensed cluster hierarchy.\n", + "The process is very similar to HDBSCAN* clustering, except that it operates on\n", + "an in-cluster eccentricity rather than a density measure. Where peaks in a\n", + "density profile correspond to clusters, the peaks in an eccentricity profile\n", + "correspond to branches:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.tri as mtri\n", + "\n", + "eccentricities = np.zeros(data.shape[0])\n", + "for label in range(len(clusterer.cluster_persistence_)):\n", + " mask = clusterer.labels_ == label\n", + " centroid = np.average(\n", + " data[mask],\n", + " weights=clusterer.probabilities_[mask],\n", + " axis=0,\n", + " )\n", + " eccentricities[mask] = np.linalg.norm(data[mask] - centroid, axis=1)\n", + "\n", + "fig = plt.figure()\n", + "tri = mtri.Triangulation(data[:, 0], data[:, 1])\n", + "ax = fig.add_subplot(1, 1, 1, projection=\"3d\", computed_zorder=False)\n", + "ax.view_init(elev=45, azim=-100)\n", + "ax.scatter(\n", + " data.T[0],\n", + " data.T[1],\n", + " np.repeat(eccentricities.min(), data.shape[0]),\n", + " s=2,\n", + " edgecolor=\"none\",\n", + " linewidth=0,\n", + ")\n", + "ax.tricontour(tri, eccentricities, levels=np.linspace(0, eccentricities.max(), 15))\n", + "ax.set_xticklabels([])\n", + "ax.set_yticklabels([])\n", + "ax.set_zticklabels([])\n", + "zlim = ax.get_zlim()\n", + "ax.set_box_aspect(aspect=(3, 3, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the branch detection functionality is fairly straightforward. First, run\n", + "hdbscan with parameter `branch_detection_data=True`. This tells hdbscan to cache\n", + "the internal data structures needed for the branch detection process. Then,\n", + "configure the ``BranchDetector`` class and fit is with the HDBSCAN object.\n", + "\n", + "The resulting partitioning reflects subgroups for clusters and their\n", + "branches:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "clusterer = HDBSCAN(min_cluster_size=15, branch_detection_data=True).fit(data)\n", + "branch_detector = BranchDetector(min_branch_size=15).fit(clusterer)\n", + "plot(branch_detector.labels_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parameter selection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `BranchDetector`'s main parameters are very similar to HDBSCAN\\*. Most\n", + "guidelines for tuning HDBSCAN\\* also apply for the branch detector:\n", + "\n", + "- `min_branch_size` behaves like HDBSCAN\\*'s `min_cluster_size`. It configures\n", + " how many points branches need to contain. Values around 10 to 25 points tend\n", + " to work well. Lower values are useful when looking for smaller structures.\n", + " Higher values can be used to suppress noise if present.\n", + "- `branch_selection_method` behaves like HDBSCAN\\*'s `cluster_selection_method`.\n", + " The leaf and Excess of Mass (EOM) strategies are used to select branches from\n", + " the condensed hierarchies. By default, branches are only reflected in the\n", + " final labelling for clusters that have 3 or more branches (at least one\n", + " bifurcation).\n", + "- `branch_selection_persistence` replaces HDBSCAN\\*'s `cluster_selection_epsilon`.\n", + " This parameter can be used to suppress branches with a short eccentricity\n", + " range (y-range in the condensed hierarchy plot).\n", + "- `allow_single_branch` behaves like HDBSCAN\\*'s `allow_single_cluster` and\n", + " mostly affects the EOM selection strategy. When enabled, clusters with\n", + " bifurcations will be given a single label if the root segment contains most\n", + " eccentricity mass (i.e., branches already merge far from the center and most\n", + " poinst are central).\n", + "- `max_branch_size` behaves like HDBSCAN\\*'s `max_cluster_size` and mostly\n", + " affects the EOM selection strategy. Branches with more than the specified\n", + " number of points are skipped, selecting their descendants in the hierarchy\n", + " instead.\n", + "\n", + "Two parameters are unique to the `BranchDetector` class:\n", + "\n", + "- `branch_detection_method` determines which points are connected within a\n", + " cluster. Both density-based clustering and the branch detection process need\n", + " to determine which points are part of the same density/eccentricity peak.\n", + " HDBSCAN\\* defines density in terms of the distance between points, providing\n", + " natural way to define which points are connected at some density value.\n", + " Eccentricity does not have such a connection. So, we use information from the\n", + " clusters to determine which points should be connected instead.\n", + " - The `\"core\"` method selects all edges that could be part of the cluster's\n", + " minimum spanning tree under HDBSCAN\\*'s mutual reachability distance. This\n", + " graph contains the detected MST and all `min_samples`-nearest neighbours. \n", + " - The `\"full\"` method connects all points with a mutual reachability lower\n", + " than the maximum distance in the cluster's MST. It represents all connectity\n", + " at the moment the last point joins the cluster. These methods differ in\n", + " their sensitivity, noise robustness, and computational cost. The `\"core\"`\n", + " method usually needs slightly higher `min_branch_size` values to suppress\n", + " noisy branches than the `\"full\"` method. It is a good choice when branches\n", + " span large density ranges.\n", + "- `label_sides_as_branches` determines whether the sides of an elongated cluster\n", + " without bifurcations (l-shape) are represented as distinct subgroups. By\n", + " default a cluster needs to have one bifurcation (Y-shape) before the detected\n", + " branches are represented in the final labelling." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Useful attributes\n", + "\n", + "Like the HDBSCAN class, the BranchDetector class contains several useful\n", + "attributes for exploring datasets.\n", + "\n", + "### Branch hierarchy\n", + "\n", + "Branch hierarchies reflect the tree-shape of clusters. Like the cluster\n", + "hierarchy, branch hierarchies can be used to interpret which branches exist. In\n", + "addition, they reflect how far apart branches merge into the cluster. " + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = np.argmax([len(x) for x in branch_detector.branch_persistences_])\n", + "branch_detector.cluster_condensed_trees_[idx].plot(\n", + " select_clusters=True, selection_palette=[\"C3\", \"C4\", \"C5\"]\n", + ")\n", + "plt.ylabel(\"Eccentricity\")\n", + "plt.title(f\"Branches in cluster {idx}\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The length of the branches also says something about the compactness /\n", + "elongatedness of clusters. For example, the branch hierarchy for the orange\n", + "~-shaped cluster is quite different from the same hierarcy for the central\n", + "o-shaped cluster." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(6, 3))\n", + "plt.subplot(1, 2, 1)\n", + "idx = np.argmin([min(*x) for x in branch_detector.branch_persistences_])\n", + "branch_detector.cluster_condensed_trees_[idx].plot(colorbar=False)\n", + "plt.ylim([0.3, 0])\n", + "plt.ylabel(\"Eccentricity\")\n", + "plt.title(f\"Cluster {idx} (spherical)\")\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "idx = np.argmax([max(*x) for x in branch_detector.branch_persistences_])\n", + "branch_detector.cluster_condensed_trees_[idx].plot(colorbar=False)\n", + "plt.ylim([0.3, 0])\n", + "plt.ylabel(\"Eccentricity\")\n", + "plt.title(f\"Cluster {idx} (elongated)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cluster approximation graphs\n", + "\n", + "Branches are detected using a graph that approximates the connectivity within a\n", + "cluster. These graphs are available in the `cluster_approximation_graph_`\n", + "property and can be used to visualise data and the branch-detection process. The\n", + "plotting function is based on the networkx API and uses networkx functionality\n", + "to compute a layout if positions are not provided. Using UMAP to compute\n", + "positions can be faster and more expressive. Several helper functions for\n", + "exporting to numpy, pandas, and networkx are available.\n", + "\n", + "For example, a figure with points coloured by the final labelling:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "g = branch_detector.cluster_approximation_graph_\n", + "g.plot(positions=data, node_size=5, edge_width=0.2, edge_alpha=0.2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or, a figure with the edges coloured by centrality:" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "g.plot(\n", + " positions=data,\n", + " node_alpha=0,\n", + " edge_color=\"centrality\",\n", + " edge_cmap=\"turbo\",\n", + " edge_width=0.2,\n", + " edge_alpha=0.2,\n", + " edge_vmax=100,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Approximate predict\n", + "\n", + "A branch-aware ``approximate_predict_branch`` function is available to predicts\n", + "branch labels for new points. This function uses a fitted BranchDetector object\n", + "to first predict cluster labels and then the branch labels." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from hdbscan import approximate_predict_branch\n", + "\n", + "new_points = np.asarray([[0.4, 0.25], [0.23, 0.2], [-0.14, -0.2]])\n", + "clusterer.generate_prediction_data()\n", + "labels, probs, cluster_labels, cluster_probs, branch_labels, branch_probs = (\n", + " approximate_predict_branch(branch_detector, new_points)\n", + ")\n", + "\n", + "plt.scatter(\n", + " new_points.T[0],\n", + " new_points.T[1],\n", + " 140,\n", + " labels % 10,\n", + " marker=\"p\",\n", + " zorder=5,\n", + " cmap=\"tab10\",\n", + " vmin=0,\n", + " vmax=9,\n", + " edgecolor=\"k\",\n", + ")\n", + "plot(branch_detector.labels_)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}