o {iM@sjddlZddlmZmZddlmZddlmZm Z ddl m Z ddl m Z m Z ddlmZdd lmZdd lmZmZmZdd lmZdd lmZdd lmZ          d4ddZ  d5ddZ  d6ddZddZddZ ddZ!ddZ"dd Z#  d5d!d"Z$ d7d#d$Z%d%d&Z&d'd(Z'd8d*d+Z(d,d-Z)Gd.d/d/eeZ*d0d1Z+Gd2d3d3Z,dS)9N) BaseEstimator ClusterMixin) coo_array)minimum_spanning_treeconnected_components)Memory)Paralleldelayed) cpu_count)label) CondensedTreeSingleLinkageTreeApproximationGraph)approximate_predict)recurse_leaf_dfs)_tree_to_labelsfullFc  CsD|jdur td|jdurtd|dur|j}|dur |j}|dur'|j}|dur.|j}t| } t| } t t |tj rC|dksKtd|dt t | tj rX| dks`td| dt t | tj rm| dksutd | d|d vrtd |d |d vrtd|d|j } t| trt| dd} |durd} t|j} t|j|j|j|j|j|jd\}}|dur|}nd} |d} |durt|dkdd}|jjs|jj}||}||}|dk}|j}|dkrttd|d}|rtnt|dd}| j t!dgd|||j|jj"|jj#|jj$|jj%| ||| d \}}}}| j t&dgd|||||| | |d\}}}}}| t'||||||||d\}}}}}|jjs|jj(}t)||t*||t|j}t+|||}t,|||}t+|||}t,|||}t+|||d}t,|||}t,|||}||||||||||||f S)a( 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. cluster_labels : np.ndarray, shape (n_samples, ), optional (default=None) The cluster labels for each point in the data set. If not provided, the clusterer's labels will be used. cluster_probabilities : np.ndarray, shape (n_samples, ), optional (default=None) The cluster probabilities for each point in the data set. If not provided, the clusterer's probabilities will be used, or all points will be given 1.0 probability if labels are overridden. branch_detection_method : str, optional (default=``full``) Determines which graph is constructed 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. 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. Enabling this flag separates these branches from each other in the produced labelling. min_cluster_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_cluster : bool, optional (default=None) Analogous to HDBSCAN's ``allow_single_cluster``. cluster_selection_method : str, optional (default=None) 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`` cluster_selection_epsilon: float, optional (default=0.0) A lower epsilon threshold. Only branches with a death above this value will be considered. 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:`~hdbscan.branches.approximate_predict` function is not aware of this argument. cluster_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:`~hdbscan.branches.approximate_predict` function is not aware of this argument. max_cluster_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:`~hdbscan.branches.approximate_predict`), as that function is not aware of this argument. 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. cluster_labels : np.ndarray, shape (n_samples, ) The cluster labels for each point in the data set. Noisy samples are given the label -1. cluster_probabilities : np.ndarray, shape (n_samples, ) The cluster probabilities for each point in the data set. Noisy samples are assigned 1.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. 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. 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. 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. 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. 2025. FLASC: a flare-sensitive clustering algorithm. PeerJ Computer Science 11:e2792 https://doi.org/10.7717/peerj-cs.2792. NzClusterer does not have an explicit minimum spanning tree! Try fitting with branch_detection_data=True or gen_min_span_tree=True set.zClusterer does not have branch detection data! Try fitting with branch_detection_data=True set, or run generate_branch_detection_data on the clustererzr"num_jobsr points centralities linkage_treesapproximation_graphs branch_labelsbranch_probabilitiesbranch_persistencescondensed_treeslabels probabilitiesrI num_pointsr`D/home/ubuntu/.local/lib/python3.10/site-packages/hdbscan/branches.pydetect_branches_in_clusterssB +                 rbc Csp|r4t|dkr4t|}t|}|dkr4|ddk}|dd|k}|d||@}d||<d||<||fS)zhSets all points up to cluster_selection_epsilon to the zero-cluster if a single cluster is detected.r r child_size lambda_valchildr)r5r- zeros_like ones_like) condensed_treer]r^ persistencesrr size_mask lambda_mask noise_pointsr`r`rar7rs   r7c sB|f ddt|D} t| rtt| SdS)Nc 3s.|]}tt| VqdSN)r "_compute_branch_linkage_of_cluster).0 cluster_id rOrPrErFmin_spanning_treerDr#r" space_treer`ra s   z)compute_branch_linkage..)r`r`r`r`)ranger5tuplezip) rOrPrrrsrDrErFrRr r"r#resultr`rqrarBs    rBc Cs|| k} t| d} tj|jddtjd} tjt| tjd| | <||dddftj| k} ||dddftj| k}|| |@}| |dddftj|dddf<| |dddftj|dddf<|j j | }tj ||| dd}| |d|dddf}tj dd d|}Wdn1swY|rt|||| | }n|jd }t||| | |}t| |||S) z#Detect branches within one cluster.rrdtypeNr weightsaxisr!)divider)r-r<rshapedoublearanger5astypeintpdatabaseaveragepairwiseerrstateextract_core_cluster_graphTr;extract_full_cluster_graph!compute_branch_linkage_from_graph)rOrPrrrsrDrErFr"r#rp cluster_maskcluster_pointsin_cluster_ids parent_mask child_mask cluster_mstrUcentroidrVedgesmax_distr`r`rarns4   ((    rncCsrt||dddftj||dddftj|dddftt|dddf|dddftj|dddftjfft|t|fddd}||dddftj|dddf<||dddftj|dddf<|rt|dd\}}|dkr||||fS| }t |j |j |j f}|t|dddfddf}t|}||||fS) Nrr r)rT) overwriteF)directed)r-maximumrrrrint32r5rtocoo column_stackrowcolrargsortr )rrVrr#centrality_mstnum_componentsr] linkage_treer`r`rars2>( ( " rc Cs|jd}|jd}|jd}tj|||dftjd}|dddftj}|dddftj} t|| |d|dft|| |d|dfttj |tjd|} || } t| | ||ddft| | ||ddf|dddf|d|df<t|||ddftj|||ddftj||ddftj ||dddfdkddfdd }|S) zGCreate a graph connecting all points within each point's core distance.rr ryNrr}) rr-zerosrrrminimumrrepeatrflattenunique) cluster_spanning_treerErDrr_ num_neighborscountr mst_parents mst_children core_parent core_childrenr`r`rars(    *rc Cs@|j|jj||ddd\}}tjt|tjd}t|D]\}} ||t| 7<qttj t|tj d|} |t |} t |} | dk| | k@| |k@} tj| dftj d}| | |dddf<| | |dddf<t t ||dddftj||dddftj| | |ddd f|S) Ng:0yE>T)rreturn_distanceryrrrr r) query_radiusrrr-rr5r enumeraterrr concatenatesumrr)rsrErrr children_map distances_map num_childrenichildren full_parents full_childrenfull_distancesmaskrr`r`rar,s:  rc s.|fdd|D}t|rtt|SdS)z/Extracts branches from the linkage hierarchies.c3s$|] }tt|fiVqdSrm)r segment_branch_linkage_hierarchy)rocluster_linkage_treekwargsr`rartVs  z.compute_branch_segmentation..)r`r`r`r`r`)r5rvrw)cluster_linkage_treesr rresultsr`rrarGTs  rGc Kst|jdkr"|tj|jdtjdddt|dDddfStd|f||d|\}}}}}t||||||d\}}|||||fS)z#Select branches within one cluster.r rrycSsg|]}dqS)rr`)ro_r`r`ra ksz4segment_branch_linkage_hierarchy..Nr) r5rr-onesrrur;rr7) single_linkage_treerrrr]r^ stabilitiesrhrr`r`rar_s4    rcCst|}dtj|tjd} |} tj|tjd} tj|tjd} tj|tjd} d}t||||||D]Q\}}}}}}t|}|| |<||rJdndkrZ|durZ|| |<|d7}q5td|v}|||| |<|| |<|| |<| ||7<| |d<|||7}q5| | | | | fS)z1Updates the labelling with the detected branches.rryrr rN) r5r-rrcopyrrrwint)rP tree_list points_listcentrality_listbranch_label_listbranch_prob_listbranch_pers_listr(r_r]r^rYrZbranch_centralities running_idrC_points_labels_probs_centrs_pers num_branches has_noiser`r`rarHsB   rHcCs8|D]}|D]}||d|d<||d|d<qqdS)aU 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. rr Nr`) edge_listsrIgraphedger`r`rarKs  rKcCs0|D]}tt|D] }|||||<q qdS)a/ 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. N)rur5) point_listsrIrUidxr`r`rarJs  rJrcCst||}|||<|S)z7Creates new label array with infinite points set to -1.)r-r) old_labelsr>r_ fill_value new_labelsr`r`rarLs rLcCst|}|||<|S)zr_ new_probsr`r`rarMs rMc@seZdZdZ        dddZddd Zdd d Zdd d ZdddZe ddZ e ddZ e ddZ e ddZ dS)BranchDetectora4Performs 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 ---------- branch_detection_method : str, optional (default=``full``) Determines which graph is constructed 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. 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. Enabling this flag separates these branches from each other in the produced labelling. min_cluster_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_cluster : bool, optional (default=None) Analogous to ``allow_single_cluster``. cluster_selection_method : str, optional (default=None) 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`` cluster_selection_epsilon: float, optional (default=0.0) A lower epsilon threshold. Only branches with a death above this value will be considered. cluster_selection_persistence: float, optional (default=0.0) An eccentricity persistence threshold. Branches with a persistence below this value will be merged. max_cluster_size : int, optional (default=None) 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 because `approximate_predict` is not aware of this argument. 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. cluster_labels_ : np.ndarray, shape (n_samples, ) The cluster labels for each point in the data set. Noisy samples are given the label -1. cluster_probabilities_ : np.ndarray, shape (n_samples, ) The cluster probabilities for each point in the data set. Noisy samples are assigned 1.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. approximation_graph_ : ApproximationGraph 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. 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. 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. 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. 2025. FLASC: a flare-sensitive clustering algorithm. PeerJ Computer Science 11:e2792 https://doi.org/10.7717/peerj-cs.2792. rFNrc CsL||_||_||_||_||_||_||_||_d|_d|_ d|_ d|_ dSrm) rQr(r$r'rr%rr&_approximation_graphs_condensed_trees_cluster_linkage_trees_branch_exemplars) selfrQr(r$r'rr%rr&r`r`ra__init__ps  zBranchDetector.__init__c CsV||_|}t|||fi|\ |_|_|_|_|_|_|_ |_ |_ |_ |_ |_|S)aI Perform a flare-detection post-processing step to detect branches within clusters. Parameters ---------- clusterer : HDBSCAN A fitted HDBSCAN object with branch detection data generated. labels : np.ndarray, shape (n_samples, ), optional (default=None) The cluster labels for each point in the data set. If not provided, the clusterer's labels will be used. probabilities : np.ndarray, shape (n_samples, ), optional (default=None) The cluster probabilities for each point in the data set. If not provided, the clusterer's probabilities will be used, or all points will be given 1.0 probability if labels are overridden. Returns ------- self : object Returns self. ) _clusterer get_paramsrbr9r:cluster_labels_cluster_probabilities_branch_labels_branch_probabilities_branch_persistences_rr_linkage_trees centralities_cluster_points_)rrNr]r^rr`r`rafits"zBranchDetector.fitcCs|||||jS)a Perform a flare-detection post-processing step to detect branches within clusters [1]_. Parameters ---------- clusterer : HDBSCAN A fitted HDBSCAN object with branch detection data generated. labels : np.ndarray, shape (n_samples, ), optional (default=None) The cluster labels for each point in the data set. If not provided, the clusterer's labels will be used. probabilities : np.ndarray, shape (n_samples, ), optional (default=None) The cluster probabilities for each point in the data set. If not provided, the clusterer's probabilities will be used, or all points will be given 1.0 probability if labels are overridden. Returns ------- labels : ndarray, shape (n_samples, ) subgroup labels differentiated by cluster and branch. )rr9)rrNr]r^r`r`ra fit_predictszBranchDetector.fit_predictcCsz|jdur td|jjdur|durtd|dkrtd|dur'|jj}|j|k}||}|j|}tj||ddS)aProvides 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``. NModel has not been fit to dataRaw data not availablerMCannot calculate weighted centroid for -1 cluster since it is a noise clusterrr{)r9AttributeErrorr _raw_datar*r:r-r)rlabel_idrr cluster_datacluster_membership_strengthsr`r`raweighted_centroids   z BranchDetector.weighted_centroidc Cs|jdur td|jjdur|durtd|dkrtd|dur'|jj}|j|k}||}|j|}|jjj}|||}t |j dd}||S)aProvides 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``. Nrrrrr r) r9rrrr*r:r+rFrr-argminr) rrrrrrrFdist_mat medoid_indexr`r`raweighted_medoids"    zBranchDetector.weighted_medoidc CsD|jdur tdt|j|j|j|j|j|j|j|j dd|j j d S)@See :class:`~hdbscan.branches.BranchDetector` for documentation.Nz.)rrrwrr r`r racondensed_trees_0s  zBranchDetector.condensed_trees_cCs"|jdur tddd|jDS)rNz7No linkage trees were generated; try running fit first.cSs g|] }|dur t|ndqSrm)r)rorCr`r`rarGsz1BranchDetector.linkage_trees_..)rrr r`r`ralinkage_trees_@s zBranchDetector.linkage_trees_cCs\|jdur|jS|jjdurtd|jdurtdt|j}dd|jD}dd|jD}dg||_t|jD]o\}}||}t||j rKdndkrOq;g|j|<|j|}|D]N}t j gt j d } t ||t |D]%} |d |d | k} |d |d | k|d | k@} t | | g} qo|| } |j||jj| ddfq[q;|jS) rNz:Branch exemplars not available with precomputed distances.z,No branches detected; try running fit first.cSsg|] }||ddkqS)rcr r`ro branch_treer`r`rarYsz-BranchDetector.exemplars_..cSsg|]}t|qSr`)sorted_select_clustersrr`r`rar]s r rryrdparentre)rrrrrr5rrrr(r-arrayrrr;hstackappend)rrRbranch_cluster_treesselected_branch_idsrrUselected_branchesraw_condensed_treer rrleaf_max_lambda candidatesidsr`r`ra exemplars_LsP          "zBranchDetector.exemplars_)rFNNNNrr)NNrm)__name__ __module__ __qualname____doc__rrrrrpropertyrrrr r`r`r`rars0  +  $(    rcCst|j|dd\}}}t|}tj|tjd}tj|tjd}tj|tjd}tj|tjd} |j s4dnd} t t |||D]A\} \} } }| dkrNd|| <q>t|j | | kr`| || <| || <q>|j ||| <|j||| <|j|| | <| | | d|| <q>|||||| fS)aDPredict 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 input 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. T)return_connecting_pointsryrr rr)rrr5r-emptyrrrrr(rrwrr9rr)branch_detectorpoints_to_predictrOrPconnecting_points num_predictr]r^rYrZmin_num_branchesrr probconnecting_pointr`r`raapproximate_predict_branch}s<%    r/c@s eZdZdZddZddZdS)r@z6API of a Joblib Parallel pool but sequential executioncCs d|_dS)Nr )rr r`r`rars zSequentialPool.__init__cCsdd|DS)NcSs g|] \}}}||i|qSr`r`)rofunargsrr`r`rars z+SequentialPool.__call__..r`)rjobsr`r`ra__call__szSequentialPool.__call__N)r!r"r#r$rr3r`r`r`rar@s r@) NNrFNNNNrr)Fr)FF)F)r)-numpyr- sklearn.baserr scipy.sparserscipy.sparse.csgraphrrjoblibrrr joblib.parallelr _hdbscan_linkager plotsr rr predictionr _hdbscan_treerhdbscan_rrbr7rBrnrrrrGrrHrKrJrLrMrr/r@r`r`r`rasf        h ! !2*&(  . 5 I