:i SrSSKrSSKJrJrJrJr SSKJrJ r SSK r SSK J r SSKJr SSKJrJrJrJr SS KJr SS KJr SS KJrJr SS KJr SS KJr SSK J!r!J"r"J#r#J$r$J%r% SSK&J'r' SSK(J)r) SSK*J+r, SSK-J.r. Sr/Sr0\%"S//SQ\#"\SSSS9S/S/S.SS9SSSS.S j5r1S+S!jr2S"r3S#r4S$r5\6"\1\3\4\5S%9r7S&r8"S'S(\\5r9"S)S*\\9\.5r:g),zHierarchical Agglomerative Clustering These routines perform some hierarchical agglomerative clustering of some input data. Authors : Vincent Michel, Bertrand Thirion, Alexandre Gramfort, Gael Varoquaux License: BSD 3 clause N)heapifyheappopheappush heappushpop)IntegralReal)sparse)connected_components) BaseEstimatorClassNamePrefixFeaturesOutMixin ClusterMixin _fit_context)DistanceMetric)METRIC_MAPPING64)_VALID_METRICSpaired_distances) check_array) IntFloatDict) HasMethodsHiddenInterval StrOptionsvalidate_params)_fix_connected_components) check_memory)_hierarchical_fast)AgglomerationTransformc URSnURSU:wdURSU:wa'[SUR<SUR<35eXR-n[R"U5(d[R "U5nUR S:waUR5n[U5upEUS:a&[R"SU-SS9 [UUUUUS S 9nX4$) a Fixes the connectivity matrix. The different steps are: - copies it - makes it symmetric - converts it to LIL if necessary - completes it if necessary. Parameters ---------- X : array-like of shape (n_samples, n_features) Feature matrix representing `n_samples` samples to be clustered. connectivity : sparse matrix, default=None Connectivity matrix. Defines for each sample the neighboring samples following a given structure of the data. The matrix is assumed to be symmetric and only the upper triangular half is used. Default is `None`, i.e, the Ward algorithm is unstructured. affinity : {"euclidean", "precomputed"}, default="euclidean" Which affinity to use. At the moment `precomputed` and ``euclidean`` are supported. `euclidean` uses the negative squared Euclidean distance between points. Returns ------- connectivity : sparse matrix The fixed connectivity matrix. n_connected_components : int The number of connected components in the graph. rrz%Wrong shape for connectivity matrix: z when X is lilzxthe number of connected components of the connectivity matrix is %d > 1. Completing it to avoid stopping the tree early.r  stacklevel connectivity)Xgraphn_connected_componentscomponent_labelsmetricmode) shape ValueErrorTr issparse lil_matrixformattolilr warningswarnr)r%r$affinity n_samplesr'labelss a/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/sklearn/cluster/_agglomerative.py_fix_connectivityr80sF I! )\-?-?-Bi-O!!177 ,   ..0L ??< ( (((6 e##))+ &:,%G"!  ')? @  1#9#    //cSSKJn UR[RSS9n[R "UR RS9RnXpR UR S:H'U"UR55nUR5nSUR UR U:H'[R"URURUR /5Rn U [R"U RSSS9S S 24n [ R""U 5n U S S 2S S24R[$5n [R&"U[R(S9n [+X5H&un upUbX:a OX:aXU'X:dM"XU'M( U(aU S S 2S4nXXU4$XX4$) z Perform single linkage clustering on sparse data via the minimum spanning tree from scipy.sparse.csgraph, then using union-find to label. The parent array is then generated by walking through the tree. r)minimum_spanning_treeFcopydtyper mergesortkindN)scipy.sparse.csgraphr;astypenpfloat64finfodatar?epstocsrtocoovstackrowcolr-argsort _hierarchical_single_linkage_labelintarangeintp enumerate)r$r5n_nodes n_clustersr'return_distancer; epsilon_valuemst mst_arraysingle_linkage_tree children_parentileftright distancess r7_single_linkage_treerc|s; &&rzz&>LHH<#4#4#:#:;??M0=l''1,- 2 2 4 5C ))+C+,CHHSXX &' 377CGGSXX6799I"**Y[[^+FIJI(==iH#ArrE*11#6IYYwbgg .F%i;=D  !al  >4L ?5M <'1- )YNN i ??r9 array-like)rd sparse matrixNr`closedboolean)r%r$rWrXTprefer_skip_nested_validationFr$rWrXc  [R"U5nURS:Xa[R"US5nURupEUcSSKJn Ub[R"SSS9 [R"US S 9nURU5nUSS2SS24R[R5nU(aUSS2S4n USUSU 4$USUS4$[XS S 9upUc SU-S- n OX$:a[S X$4-5eSU-U- n /n /n /n[UR 5H`unnUR#U5 UVs/sH nUU:dM UPM nnU R%['U5U/-5 U R%U5 Mb [R("U [RSS9n [R("U [RSS9n [R*"U SS9nSUSU&[R*"X4SS9nUUSU&[R,"['U 5[R.SS9n[0R2"UUXU5 [5[7UX55n[9U5 [R:"U [RS9n[R<"U [>S9n/nU(a[R,"X- 5n [R,"U [>SS9n[AXK5GHn[CU5unnnUU(a UU(aOM&UUsUU'UU'UR#UU45 S=UU'UU'U(aUW UU- 'UUUU-UU'UUUU-UU'/n URES5 SUU'[0RF"UUU UU5 [0RF"UUU UU5 U Vs/sHnUUR#U5PM nUR#U 5 [R("U [RSS9n [R,"U R[RSS9n U REU5 ['U 5n[R,"U[R.SS9n[0R2"UUXU5 [AU5Vs/sHn[IUUUUU U45PM nGM Un UV!s/sH n!U!SSS2PM nn![R("U5nU(a [RJ"SW -5n UU U UU 4$UU U U4$s snfs snfs snfs sn!f)aWard clustering based on a Feature matrix. Recursively merges the pair of clusters that minimally increases within-cluster variance. The inertia matrix uses a Heapq-based representation. This is the structured version, that takes into account some topological structure between samples. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Feature matrix representing `n_samples` samples to be clustered. connectivity : {array-like, sparse matrix}, default=None Connectivity matrix. Defines for each sample the neighboring samples following a given structure of the data. The matrix is assumed to be symmetric and only the upper triangular half is used. Default is None, i.e, the Ward algorithm is unstructured. n_clusters : int, default=None `n_clusters` should be less than `n_samples`. Stop early the construction of the tree at `n_clusters.` This is useful to decrease computation time if the number of clusters is not small compared to the number of samples. In this case, the complete tree is not computed, thus the 'children' output is of limited use, and the 'parents' output should rather be used. This option is valid only when specifying a connectivity matrix. return_distance : bool, default=False If `True`, return the distance between the clusters. Returns ------- children : ndarray of shape (n_nodes-1, 2) The children of each non-leaf node. Values less than `n_samples` correspond to leaves of the tree which are the original samples. A node `i` greater than or equal to `n_samples` is a non-leaf node and has children `children_[i - n_samples]`. Alternatively at the i-th iteration, children[i][0] and children[i][1] are merged to form node `n_samples + i`. n_connected_components : int The number of connected components in the graph. n_leaves : int The number of leaves in the tree. parents : ndarray of shape (n_nodes,) or None The parent of each node. Only returned when a connectivity matrix is specified, elsewhere 'None' is returned. distances : ndarray of shape (n_nodes-1,) Only returned if `return_distance` is set to `True` (for compatibility). The distances between the centers of the nodes. `distances[i]` corresponds to a weighted Euclidean distance between the nodes `children[i, 1]` and `children[i, 2]`. If the nodes refer to leaves of the tree, then `distances[i]` is their unweighted Euclidean distance. Distances are updated in the following way (from scipy.hierarchy.linkage): The new entry :math:`d(u,v)` is computed as follows, .. math:: d(u,v) = \sqrt{\frac{|v|+|s|} {T}d(v,s)^2 + \frac{|v|+|t|} {T}d(v,t)^2 - \frac{|v|} {T}d(s,t)^2} where :math:`u` is the newly joined cluster consisting of clusters :math:`s` and :math:`t`, :math:`v` is an unused cluster in the forest, :math:`T=|v|+|s|+|t|`, and :math:`|*|` is the cardinality of its argument. This is also known as the incremental algorithm. Examples -------- >>> import numpy as np >>> from sklearn.cluster import ward_tree >>> X = np.array([[1, 2], [1, 4], [1, 0], ... [4, 2], [4, 4], [4, 0]]) >>> children, n_connected_components, n_leaves, parents = ward_tree(X) >>> children array([[0, 1], [3, 5], [2, 6], [4, 7], [8, 9]]) >>> n_connected_components 1 >>> n_leaves 6 rrNr hierarchyPartial build of the tree is implemented only for structured clustering (i.e. with explicit connectivity). The algorithm will build the full tree and only retain the lower branches required for the specified number of clustersr r"W) requirements euclideanr4z]Cannot provide more clusters than samples. %i n_clusters was asked, and there are %i samples.C)r?order)rwr>Frng@)&rEasarrayndimreshaper+ scipy.clusterrpr2r3requirewardrDrTr8r,rUrowsappendextendlenarrayzerosemptyrFrPcompute_ward_distlistziprrSonesboolrangerfill _get_parentsrsqrt)"r%r$rWrXr5 n_featuresrpoutr]rbr'rV coord_row coord_colAindrMr_ moments_1 moments_2inertiar^ used_nodechildren not_visitedkinertjrN n_additionsiniidxn_leavescs" r7 ward_treersZ 1 Avv{ JJq' "GGI+  ! MM;  JJqs +nnQ2A2J%%bgg. AqD IaD); ;aD0 0+< +,(Li-!#  !(45  i-*,II Al//0S  )#QSq#) H  1"''=I"''=I,IIjy'.c:IIjyhhs9~RZZsCG##Iy)PWX3w 56G GYYwbgg .Ft,IHHHW01 ((7$c:K9 &!'*KE1a| !  !!q 6!9A&++ ! y| ',Ia)m $!|il2 !  |il2 !   A""1Q4FKH""1Q4FKH%./Yc3q Y/ HHYbggSA HHY__BGG3G q)n hh{"**C@'' 9iTWXFK;EWXEWc'CHa38 9EWXE'JH!)*A$B$H*xx!HGGC)O, /69LL/6AA_*n 0 Y +s T.T.T3+T8T=c  ^%[R"U5nURS:Xa[R"US5nURupg[ R [ RSS.nXn US:Xa:[R"[R"USS 9)5(a [S 5eUGcS S K J n Ub[R"S SS9 US:XacURS URS:wa[SUR35e[R "URS SS9upX U 4nOTUS:XaSnOKUS;aSnOB[#U5(a2U"U5n[R "URS SS9upX U 4nUS:XaUS:wa[#U5(dU[$;a[&R("U5n[R*"U[R,S9n[ R."X5nU[R0"UR2SSS9SS24n[ R4"U5nOU R7XUS9nUSS2SS24R9[:SS9nU(aUSS2S4nUSUSU4$USUS4$[=XUS9unnUR?5nUR@URB:gnUR@UUl URBUUl!URDUUl"AUS:Xa7XR@URB4R9[RFSS9nO#[IXR@XRBUS9nUUl"Uc SU-S- nOX&::deSU-U- nUS:Xa[KUUUUUU5$U(a[RL"UU- 5n[RL"U[NS9n[Q5nURS5n[U[WURDURX55Hum%unn[[[R"U[R\S9[R"U[RFS95UT%'UR_U%4S j[WUU555 M A[aU5 [Rb"U[R\S9n[Rd"U[R\S9n/n[gUU5GHn[iU5nUURj(aUURl(aOM6URjn URln U(aURnUUU- 'U=UU 'UU 'URqX45 UU nUU n UU -UU'S=UU 'UU 'U "UU UU UUU 5n!U!H=un"n#UU"RqUU#5 [sU[ Rt"U#UU"55 M? U!UU'S =UU 'UU 'GM Un$[Rv"U5SS2SSS!24nU(aUUU$UU4$UUU$U4$![a(n [SUR5<SU<S35U eSn A ff=f)"a Linkage agglomerative clustering based on a Feature matrix. The inertia matrix uses a Heapq-based representation. This is the structured version, that takes into account some topological structure between samples. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Feature matrix representing `n_samples` samples to be clustered. connectivity : sparse matrix, default=None Connectivity matrix. Defines for each sample the neighboring samples following a given structure of the data. The matrix is assumed to be symmetric and only the upper triangular half is used. Default is `None`, i.e, the Ward algorithm is unstructured. n_clusters : int, default=None Stop early the construction of the tree at `n_clusters`. This is useful to decrease computation time if the number of clusters is not small compared to the number of samples. In this case, the complete tree is not computed, thus the 'children' output is of limited use, and the 'parents' output should rather be used. This option is valid only when specifying a connectivity matrix. linkage : {"average", "complete", "single"}, default="complete" Which linkage criteria to use. The linkage criterion determines which distance to use between sets of observation. - "average" uses the average of the distances of each observation of the two sets. - "complete" or maximum linkage uses the maximum distances between all observations of the two sets. - "single" uses the minimum of the distances between all observations of the two sets. affinity : str or callable, default='euclidean' Which metric to use. Can be 'euclidean', 'manhattan', or any distance known to paired distance (see metric.pairwise). return_distance : bool, default=False Whether or not to return the distances between the clusters. Returns ------- children : ndarray of shape (n_nodes-1, 2) The children of each non-leaf node. Values less than `n_samples` correspond to leaves of the tree which are the original samples. A node `i` greater than or equal to `n_samples` is a non-leaf node and has children `children_[i - n_samples]`. Alternatively at the i-th iteration, children[i][0] and children[i][1] are merged to form node `n_samples + i`. n_connected_components : int The number of connected components in the graph. n_leaves : int The number of leaves in the tree. parents : ndarray of shape (n_nodes, ) or None The parent of each node. Only returned when a connectivity matrix is specified, elsewhere 'None' is returned. distances : ndarray of shape (n_nodes-1,) Returned when `return_distance` is set to `True`. distances[i] refers to the distance between children[i][0] and children[i][1] when they are merged. See Also -------- ward_tree : Hierarchical clustering with ward linkage. rrmN)completeaveragesinglez1Unknown linkage option, linkage should be one of z, but z was givencosine)axisz;Cosine affinity cannot be used when X contains zero vectorsrrorqr r" precomputedz6Distance matrix should be square, got matrix of shape )rl2rt)l1 manhattan cityblockrr>r@rA)methodr)Fr<ru)r)c3h># UH'upUT:dM [R"UTU5v M) g7fN)rP WeightedEdge).0rdrs r7 linkage_tree..s4 >LdaPQTWPW 1M & &q#q 1 1ns 22rn)A#tn  Q  GYYwbgg .Frww/IH9g &7#D Ytvv%6 FF FF '+{{Ia)m $ !!q F1IllSy ! &++ ! y|adAaD)S#> FC cFMM!Q  Wm88AsC D  !!qt?'DHxx!!TrT'*H/69LL +Xv ==e ##%w 0  s0X?? Y1 #Y,,Y1c"SUS'[U0UD6$)Nrrrargskwargss r7_complete_linkagers"F9  ( ((r9c"SUS'[U0UD6$)Nrrrrs r7_average_linkagers!F9  ( ((r9c"SUS'[U0UD6$)Nrrrrs r7_single_linkagers F9  ( ((r9)r}rrrcxX:a[SUSUS35e[US5S-*/n[US- 5H,nXS*U- n[X5S*5 [ X5S*5 M. [ R "U[ RS9n[U5HupxXv[R"U*X5'M! U$)aFunction cutting the ward tree for a given number of clusters. Parameters ---------- n_clusters : int or ndarray The number of clusters to form. children : ndarray of shape (n_nodes-1, 2) The children of each non-leaf node. Values less than `n_samples` correspond to leaves of the tree which are the original samples. A node `i` greater than or equal to `n_samples` is a non-leaf node and has children `children_[i - n_samples]`. Alternatively at the i-th iteration, children[i][0] and children[i][1] are merged to form node `n_samples + i`. n_leaves : int Number of leaves of the tree. Returns ------- labels : array [n_samples] Cluster labels for each point. z+Cannot extract more clusters than samples: z% clusters were given for a tree with z leaves.rnrrr>) r,maxrrrrErrTrUrP_hc_get_descendent) rWrrnodes_these_childrenlabelr_nodes r7_hc_cutrs0 9l?z S  8B< 1$ % &E :> "!8)h"67**+E1--. # HHXRWW -EU#MNm..uhIJ$ Lr9c N^\rSrSr%Sr\"\SSSS9S/\"\"\ 5S1-5\ \ "S5/\ \ "S5S/S S \ S/\"S 15S /\"\"\R555/\"\S SSS9S/S /S.r\\S'SSSSS SSSS.Sjjr\"SS9SSj5rSrSU4SjjrSrU=r$)AgglomerativeClusteringi a Agglomerative Clustering. Recursively merges pair of clusters of sample data; uses linkage distance. Read more in the :ref:`User Guide `. Parameters ---------- n_clusters : int or None, default=2 The number of clusters to find. It must be ``None`` if ``distance_threshold`` is not ``None``. metric : str or callable, default="euclidean" Metric used to compute the linkage. Can be "euclidean", "l1", "l2", "manhattan", "cosine", or "precomputed". If linkage is "ward", only "euclidean" is accepted. If "precomputed", a distance matrix is needed as input for the fit method. .. versionadded:: 1.2 .. deprecated:: 1.4 `metric=None` is deprecated in 1.4 and will be removed in 1.6. Let `metric` be the default value (i.e. `"euclidean"`) instead. memory : str or object with the joblib.Memory interface, default=None Used to cache the output of the computation of the tree. By default, no caching is done. If a string is given, it is the path to the caching directory. connectivity : array-like, sparse matrix, or callable, default=None Connectivity matrix. Defines for each sample the neighboring samples following a given structure of the data. This can be a connectivity matrix itself or a callable that transforms the data into a connectivity matrix, such as derived from `kneighbors_graph`. Default is ``None``, i.e, the hierarchical clustering algorithm is unstructured. For an example of connectivity matrix using :class:`~sklearn.neighbors.kneighbors_graph`, see :ref:`sphx_glr_auto_examples_cluster_plot_agglomerative_clustering.py`. compute_full_tree : 'auto' or bool, default='auto' Stop early the construction of the tree at ``n_clusters``. This is useful to decrease computation time if the number of clusters is not small compared to the number of samples. This option is useful only when specifying a connectivity matrix. Note also that when varying the number of clusters and using caching, it may be advantageous to compute the full tree. It must be ``True`` if ``distance_threshold`` is not ``None``. By default `compute_full_tree` is "auto", which is equivalent to `True` when `distance_threshold` is not `None` or that `n_clusters` is inferior to the maximum between 100 or `0.02 * n_samples`. Otherwise, "auto" is equivalent to `False`. linkage : {'ward', 'complete', 'average', 'single'}, default='ward' Which linkage criterion to use. The linkage criterion determines which distance to use between sets of observation. The algorithm will merge the pairs of cluster that minimize this criterion. - 'ward' minimizes the variance of the clusters being merged. - 'average' uses the average of the distances of each observation of the two sets. - 'complete' or 'maximum' linkage uses the maximum distances between all observations of the two sets. - 'single' uses the minimum of the distances between all observations of the two sets. .. versionadded:: 0.20 Added the 'single' option For examples comparing different `linkage` criteria, see :ref:`sphx_glr_auto_examples_cluster_plot_linkage_comparison.py`. distance_threshold : float, default=None The linkage distance threshold at or above which clusters will not be merged. If not ``None``, ``n_clusters`` must be ``None`` and ``compute_full_tree`` must be ``True``. .. versionadded:: 0.21 compute_distances : bool, default=False Computes distances between clusters even if `distance_threshold` is not used. This can be used to make dendrogram visualization, but introduces a computational and memory overhead. .. versionadded:: 0.24 For an example of dendrogram visualization, see :ref:`sphx_glr_auto_examples_cluster_plot_agglomerative_dendrogram.py`. Attributes ---------- n_clusters_ : int The number of clusters found by the algorithm. If ``distance_threshold=None``, it will be equal to the given ``n_clusters``. labels_ : ndarray of shape (n_samples) Cluster labels for each point. n_leaves_ : int Number of leaves in the hierarchical tree. n_connected_components_ : int The estimated number of connected components in the graph. .. versionadded:: 0.21 ``n_connected_components_`` was added to replace ``n_components_``. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 children_ : array-like of shape (n_samples-1, 2) The children of each non-leaf node. Values less than `n_samples` correspond to leaves of the tree which are the original samples. A node `i` greater than or equal to `n_samples` is a non-leaf node and has children `children_[i - n_samples]`. Alternatively at the i-th iteration, children[i][0] and children[i][1] are merged to form node `n_samples + i`. distances_ : array-like of shape (n_nodes-1,) Distances between nodes in the corresponding place in `children_`. Only computed if `distance_threshold` is used or `compute_distances` is set to `True`. See Also -------- FeatureAgglomeration : Agglomerative clustering but for features instead of samples. ward_tree : Hierarchical clustering with ward linkage. Examples -------- >>> from sklearn.cluster import AgglomerativeClustering >>> import numpy as np >>> X = np.array([[1, 2], [1, 4], [1, 0], ... [4, 2], [4, 4], [4, 0]]) >>> clustering = AgglomerativeClustering().fit(X) >>> clustering AgglomerativeClustering() >>> clustering.labels_ array([1, 1, 1, 0, 0, 0]) rNr`rfrcacherdreautorhr)rWr)memoryr$compute_full_treerdistance_thresholdcompute_distances_parameter_constraintsrtr}F)r)rr$rrrrcdXlXplX0lX@lXPlX`lX lXlgr)rWrrr$rrr)r) selfrWr)rr$rrrrs r7__init__ AgglomerativeClustering.__init__s0%"4 (!2  !2r9TricDURUSS9nURU5$)aFit the hierarchical clustering from features, or distance matrix. Parameters ---------- X : array-like, shape (n_samples, n_features) or (n_samples, n_samples) Training instances to cluster, or distances between instances if ``metric='precomputed'``. y : Ignored Not used, present here for API consistency by convention. Returns ------- self : object Returns the fitted instance. r )ensure_min_samples)_validate_data_fit)rr%ys r7fitAgglomerativeClustering.fits'&   a  8yy|r9cb[UR5nURc#[R"S[ 5 SUlOURUlURSLURSL- (d [S5eURbUR(d [S5eURS:Xa(UR S:wa[UR S35e[URnURnURb7[UR5(aURU5n[U/SQS 9n[!U5nURnURcS nUS :Xa,URbS nOUR[#S S U-5:nURnU(aSn0nURS:waURUS'UR US'URn U SL=(d UR$n UR'U5"U4UUU S.UD6n U SSuUlUlUln U (a U SUlURb,[0R2"UR.U :5S-UlOURUlU(a2[7UR4UR(UR,5UlU$[:R<"U SS9n [0R>"U SU5n [0R@"[0RB"U 5U 5UlU$)aFit without validation Parameters ---------- X : ndarray of shape (n_samples, n_features) or (n_samples, n_samples) Training instances to cluster, or distances between instances if ``metric='precomputed'``. Returns ------- self : object Returns the fitted instance. Nz`metric=None` is deprecated in version 1.4 and will be removed in version 1.6. Let `metric` be the default value (i.e. `'euclidean'`) instead.rtz_Exactly one of n_clusters and distance_threshold has to be set, and the other needs to be None.zT>Tll<(  %!+    SV QS O5t~w !"gDO  " " .  4F!FG!K   $D  "4#3#3T^^T^^TDL #//eDFWWVJY/0F??299V+[TU]X5$)a-Fit and return the result of each sample's clustering assignment. In addition to fitting, this method also return the result of the clustering assignment for each sample in the training set. Parameters ---------- X : array-like of shape (n_samples, n_features) or (n_samples, n_samples) Training instances to cluster, or distances between instances if ``affinity='precomputed'``. y : Ignored Not used, present here for API consistency by convention. Returns ------- labels : ndarray of shape (n_samples,) Cluster labels. )super fit_predictrr%r __class__s r7r#AgglomerativeClustering.fit_predictTs*w"1((r9)rr]rrr$rrrrrr)rWrrrr r)__name__ __module__ __qualname____firstlineno____doc__rrrsetrrrstrrrrrrdict__annotations__rrrrr__static_attributes__ __classcell__rs@r7rr sVr !T&A4H s>*m_< =  4L  7+T2%$G(&2I>s>#6#6#89:;'afEtL'[ $D "3 3*56*rh))r9rcn^\rSrSr%Sr\"\SSSS9S/\"\"\ 5S1-5\ \ "S5/\ \ "S5S/S S \ S/\"S 15S /\"\"\R555/\ /\"\S SSS9S/S /S. r\\S'SSSSS S\R*SSS.U4Sjjjr\"SS9SU4Sjj5r\S5rSrU=r$)FeatureAgglomerationilaAgglomerate features. Recursively merges pair of clusters of features. Read more in the :ref:`User Guide `. Parameters ---------- n_clusters : int or None, default=2 The number of clusters to find. It must be ``None`` if ``distance_threshold`` is not ``None``. metric : str or callable, default="euclidean" Metric used to compute the linkage. Can be "euclidean", "l1", "l2", "manhattan", "cosine", or "precomputed". If linkage is "ward", only "euclidean" is accepted. If "precomputed", a distance matrix is needed as input for the fit method. .. versionadded:: 1.2 .. deprecated:: 1.4 `metric=None` is deprecated in 1.4 and will be removed in 1.6. Let `metric` be the default value (i.e. `"euclidean"`) instead. memory : str or object with the joblib.Memory interface, default=None Used to cache the output of the computation of the tree. By default, no caching is done. If a string is given, it is the path to the caching directory. connectivity : array-like, sparse matrix, or callable, default=None Connectivity matrix. Defines for each feature the neighboring features following a given structure of the data. This can be a connectivity matrix itself or a callable that transforms the data into a connectivity matrix, such as derived from `kneighbors_graph`. Default is `None`, i.e, the hierarchical clustering algorithm is unstructured. compute_full_tree : 'auto' or bool, default='auto' Stop early the construction of the tree at `n_clusters`. This is useful to decrease computation time if the number of clusters is not small compared to the number of features. This option is useful only when specifying a connectivity matrix. Note also that when varying the number of clusters and using caching, it may be advantageous to compute the full tree. It must be ``True`` if ``distance_threshold`` is not ``None``. By default `compute_full_tree` is "auto", which is equivalent to `True` when `distance_threshold` is not `None` or that `n_clusters` is inferior to the maximum between 100 or `0.02 * n_samples`. Otherwise, "auto" is equivalent to `False`. linkage : {"ward", "complete", "average", "single"}, default="ward" Which linkage criterion to use. The linkage criterion determines which distance to use between sets of features. The algorithm will merge the pairs of cluster that minimize this criterion. - "ward" minimizes the variance of the clusters being merged. - "complete" or maximum linkage uses the maximum distances between all features of the two sets. - "average" uses the average of the distances of each feature of the two sets. - "single" uses the minimum of the distances between all features of the two sets. pooling_func : callable, default=np.mean This combines the values of agglomerated features into a single value, and should accept an array of shape [M, N] and the keyword argument `axis=1`, and reduce it to an array of size [M]. distance_threshold : float, default=None The linkage distance threshold at or above which clusters will not be merged. If not ``None``, ``n_clusters`` must be ``None`` and ``compute_full_tree`` must be ``True``. .. versionadded:: 0.21 compute_distances : bool, default=False Computes distances between clusters even if `distance_threshold` is not used. This can be used to make dendrogram visualization, but introduces a computational and memory overhead. .. versionadded:: 0.24 Attributes ---------- n_clusters_ : int The number of clusters found by the algorithm. If ``distance_threshold=None``, it will be equal to the given ``n_clusters``. labels_ : array-like of (n_features,) Cluster labels for each feature. n_leaves_ : int Number of leaves in the hierarchical tree. n_connected_components_ : int The estimated number of connected components in the graph. .. versionadded:: 0.21 ``n_connected_components_`` was added to replace ``n_components_``. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 children_ : array-like of shape (n_nodes-1, 2) The children of each non-leaf node. Values less than `n_features` correspond to leaves of the tree which are the original samples. A node `i` greater than or equal to `n_features` is a non-leaf node and has children `children_[i - n_features]`. Alternatively at the i-th iteration, children[i][0] and children[i][1] are merged to form node `n_features + i`. distances_ : array-like of shape (n_nodes-1,) Distances between nodes in the corresponding place in `children_`. Only computed if `distance_threshold` is used or `compute_distances` is set to `True`. See Also -------- AgglomerativeClustering : Agglomerative clustering samples instead of features. ward_tree : Hierarchical clustering with ward linkage. Examples -------- >>> import numpy as np >>> from sklearn import datasets, cluster >>> digits = datasets.load_digits() >>> images = digits.images >>> X = np.reshape(images, (len(images), -1)) >>> agglo = cluster.FeatureAgglomeration(n_clusters=32) >>> agglo.fit(X) FeatureAgglomeration(n_clusters=32) >>> X_reduced = agglo.transform(X) >>> X_reduced.shape (1797, 32) rNr`rfrrrdrerrhr) rWr)rr$rr pooling_funcrrrrtr}F)r)rr$rrr"rrc :>[T U]UUUUUUUU S9 Xplg)N)rWrr$rrr)rr)rrr") rrWr)rr$rrr"rrrs r7rFeatureAgglomeration.__init__s7 !%/1/  )r9Tric|>URUSS9n[TU] UR5 URUlU$)a Fit the hierarchical clustering on the data. Parameters ---------- X : array-like of shape (n_samples, n_features) The data. y : Ignored Not used, present here for API consistency by convention. Returns ------- self : object Returns the transformer. r )ensure_min_features)rrrr-r_n_features_outrs r7rFeatureAgglomeration.fit)s="   q  9  QSS#// r9c[e)zAFit and return the result of each sample's clustering assignment.)AttributeError)rs r7r FeatureAgglomeration.fit_predict?s r9)r'r"rr)rrrrrrrrrrrrrrrrrrrrrEmeanrrrpropertyrrrrs@r7r!r!lsOd !T&A4H s>*m_< =  4L  7+T2%$G(&2I>s>#6#6#89:;! 'afEtL'[$D$) WW))256*r9r!)NNrrtF);rr2heapqrrrrnumbersrrnumpyrEscipyr rCr baser r rrmetricsrmetrics._dist_metricsrmetrics.pairwiserrutilsrutils._fast_dictrutils._param_validationrrrrr utils.graphrutils.validationrrrP_feature_agglomerationrr8rcrrrrrrrrrr!r9r7r>s 99"5 %4?+4+2: I0X5@x^=!T&A4H%;  #'"&$gBgBZ   Q>j) ) )      ,d\)lM\)~ V#%<>TVr9