-iKSrSSKrSSKrSSKJr SSKJr SSK J r SSK J r J r Jr SSKJr SSKJrJrJrJr S S KJrJr S S KJrJrJrJr "S S 5r"SS\5rg)zBisecting K-means clustering.N) _fit_context)_openmp_effective_n_threads)IntegralInterval StrOptions) row_norms)_check_sample_weightcheck_is_fittedcheck_random_state validate_data)_inertia_dense_inertia_sparse) _BaseKMeans_kmeans_single_elkan_kmeans_single_lloyd _labels_inertia_threadpool_limitc0\rSrSrSrSrSrSrSrSr g) _BisectingTreezITree structure representing the hierarchical clusters of BisectingKMeans.cDXlX lX0lSUlSUlg)zCreate a new cluster node in the tree. The node holds the center of this cluster and the indices of the data points that belong to it. N)centerindicesscoreleftright)selfrrrs R/var/www/html/venv/lib/python3.13/site-packages/sklearn/cluster/_bisect_k_means.py__init___BisectingTree.__init__!s!      c[URUS:HUSUSS9Ul[URUS:HUSUSS9UlSUlg)z,Split the cluster node into two subclusters.rrrrrN)rrrr)rlabelscentersscoress rsplit_BisectingTree.split.s]"LL1-gajq   $LL1-gajq    r"c~SnUR5H&nUbURU:dMURnUnM( W$)zReturn the cluster node to bisect next. It's based on the score of the cluster, which can be either the number of data points assigned to that cluster or the inertia of that cluster (see `bisecting_strategy` for details). N) iter_leavesr)r max_score cluster_leafbest_cluster_leafs rget_cluster_to_bisect$_BisectingTree.get_cluster_to_bisect:sH  ,,.L L$6$6$B(.. $0!/ ! r"c## URcUv gURR5ShvN URR5ShvN gN'N7f)z0Iterate over all the cluster leaves in the tree.N)rr+r)rs rr+_BisectingTree.iter_leavesJsH 99 Jyy,,. . .zz--/ / / / /s!0AA!AAAA)rrrrrN) __name__ __module__ __qualname____firstlineno____doc__r r(r/r+__static_attributes__r"rrrsS  ! 0r"rc ^\rSrSr%Sr0\R E\"SS15\/\ "\ SSSS9/S /\"S S 15/\"S S 15/S.Er\ \ S'SSSSSSSSS S S. U4Sjjjr SrSrSr\"SS9S Sj5rSrSrU4SjrSrU=r$)!BisectingKMeansSaXBisecting K-Means clustering. Read more in the :ref:`User Guide `. .. versionadded:: 1.1 Parameters ---------- n_clusters : int, default=8 The number of clusters to form as well as the number of centroids to generate. init : {'k-means++', 'random'} or callable, default='random' Method for initialization: 'k-means++' : selects initial cluster centers for k-mean clustering in a smart way to speed up convergence. See section Notes in k_init for more details. 'random': choose `n_clusters` observations (rows) at random from data for the initial centroids. If a callable is passed, it should take arguments X, n_clusters and a random state and return an initialization. n_init : int, default=1 Number of time the inner k-means algorithm will be run with different centroid seeds in each bisection. That will result producing for each bisection best output of n_init consecutive runs in terms of inertia. random_state : int, RandomState instance or None, default=None Determines random number generation for centroid initialization in inner K-Means. Use an int to make the randomness deterministic. See :term:`Glossary `. max_iter : int, default=300 Maximum number of iterations of the inner k-means algorithm at each bisection. verbose : int, default=0 Verbosity mode. tol : float, default=1e-4 Relative tolerance with regards to Frobenius norm of the difference in the cluster centers of two consecutive iterations to declare convergence. Used in inner k-means algorithm at each bisection to pick best possible clusters. copy_x : bool, default=True When pre-computing distances it is more numerically accurate to center the data first. If copy_x is True (default), then the original data is not modified. If False, the original data is modified, and put back before the function returns, but small numerical differences may be introduced by subtracting and then adding the data mean. Note that if the original data is not C-contiguous, a copy will be made even if copy_x is False. If the original data is sparse, but not in CSR format, a copy will be made even if copy_x is False. algorithm : {"lloyd", "elkan"}, default="lloyd" Inner K-means algorithm used in bisection. The classical EM-style algorithm is `"lloyd"`. The `"elkan"` variation can be more efficient on some datasets with well-defined clusters, by using the triangle inequality. However it's more memory intensive due to the allocation of an extra array of shape `(n_samples, n_clusters)`. bisecting_strategy : {"biggest_inertia", "largest_cluster"}, default="biggest_inertia" Defines how bisection should be performed: - "biggest_inertia" means that BisectingKMeans will always check all calculated cluster for cluster with biggest SSE (Sum of squared errors) and bisect it. This approach concentrates on precision, but may be costly in terms of execution time (especially for larger amount of data points). - "largest_cluster" - BisectingKMeans will always split cluster with largest amount of points assigned to it from all clusters previously calculated. That should work faster than picking by SSE ('biggest_inertia') and may produce similar results in most cases. Attributes ---------- cluster_centers_ : ndarray of shape (n_clusters, n_features) Coordinates of cluster centers. If the algorithm stops before fully converging (see ``tol`` and ``max_iter``), these will not be consistent with ``labels_``. labels_ : ndarray of shape (n_samples,) Labels of each point. inertia_ : float Sum of squared distances of samples to their closest cluster center, weighted by the sample weights if provided. n_features_in_ : int Number of features seen during :term:`fit`. 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. See Also -------- KMeans : Original implementation of K-Means algorithm. Notes ----- It might be inefficient when n_cluster is less than 3, due to unnecessary calculations for that case. Examples -------- >>> from sklearn.cluster import BisectingKMeans >>> import numpy as np >>> X = np.array([[1, 1], [10, 1], [3, 1], ... [10, 0], [2, 1], [10, 2], ... [10, 8], [10, 9], [10, 10]]) >>> bisect_means = BisectingKMeans(n_clusters=3, random_state=0).fit(X) >>> bisect_means.labels_ array([0, 2, 0, 2, 0, 2, 1, 1, 1], dtype=int32) >>> bisect_means.predict([[0, 0], [12, 3]]) array([0, 2], dtype=int32) >>> bisect_means.cluster_centers_ array([[ 2., 1.], [10., 9.], [10., 1.]]) For a comparison between BisectingKMeans and K-Means refer to example :ref:`sphx_glr_auto_examples_cluster_plot_bisect_kmeans.py`. z k-means++randomrNr)closedbooleanlloydelkanbiggest_inertialargest_cluster)initn_initcopy_x algorithmbisecting_strategy_parameter_constraintsi,rg-C6?T) rDrE random_statemax_iterverbosetolrFrGrHc P>[T U]UUUUUUUS9 XlXlXlg)N) n_clustersrDrKrLrJrMrE)superr rFrGrH) rrOrDrErJrKrLrMrFrGrH __class__s rr BisectingKMeans.__init__s> !%   ""4r"c8[R"SUS35 g)z(Warn when vcomp and mkl are both presentzBisectingKMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=.N)warningswarn)rn_active_threadss r_warn_mkl_vcompBisectingKMeans._warn_mkl_vcomps"  )*:(:! = r"c URSn[R"U5(a[O[n[ R "U5n[U5HnU"XX#URUS9Xx'M U$)a%Calculate the sum of squared errors (inertia) per cluster. Parameters ---------- X : {ndarray, csr_matrix} of shape (n_samples, n_features) The input samples. centers : ndarray of shape (n_clusters=2, n_features) The cluster centers. labels : ndarray of shape (n_samples,) Index of the cluster each sample belongs to. sample_weight : ndarray of shape (n_samples,) The weights for each observation in X. Returns ------- inertia_per_cluster : ndarray of shape (n_clusters=2,) Sum of squared errors (inertia) for each cluster. r) single_label) shapespissparserrnpemptyrange _n_threads) rXr&r% sample_weightrO_inertiainertia_per_clusterlabels r_inertia_per_cluster$BisectingKMeans._inertia_per_clustersg,]]1% &(kk!nn?. hhz2:&E)1'4??QV*  &' #"r"c bXRnX$RnX4RnSn[UR5H~nURUUURUR SUS9nUR UUUURURURURS9uppUb XS-:dMxUn U n U nM UR(a[SW 35 URS:XaURUW W U5n O[R"W SS9n UR!U W U 5 g) aSplit a cluster into 2 subsclusters. Parameters ---------- X : {ndarray, csr_matrix} of shape (n_samples, n_features) Training instances to cluster. x_squared_norms : ndarray of shape (n_samples,) Squared euclidean norm of each data point. sample_weight : ndarray of shape (n_samples,) The weights for each observation in X. cluster_to_bisect : _BisectingTree node object The cluster node to split. Nr)x_squared_normsrDrJ n_centroidsrd)rKrLrM n_threadsg !?zNew centroids from bisection: rB) minlength)rrarE_init_centroidsrD _random_state_kmeans_singlerKrLrMrbprintrHrhr_bincountr()rrcrkrdcluster_to_bisect best_inertia_ centers_initr%inertiar& best_labels best_centersr's r_bisectBisectingKMeans._bisect(s@" '' ()*C*CD%&?&?@  t{{#A// /YY!//+ 0L+/*=*= HH//+>+ 'FW#w1J'J$ & & 3$6 << 2<.A B  " "&7 7..<mF [[:F \6Br")prefer_skip_nested_validationc [UUS[R[R/SURSS9nUR U5 [ UR5Ul[X1URS9n[5Ul URS:XdURS:Xa*[UlUR#XR$S5 O [&Ul[(R*"U5(d"UR-SS 9UlXR.-n[1[R2"UR$S5UR-SS 9SS 9Ul[7US S 9n[9URS- 5H/nUR4R;5nUR=XX65 M1 [R>"UR$SS [R@S9Ul![RD"URUR$S4URS9Ul#[IUR4RK55HCupxXpRBURL'URNURFU'Xxl(SUl&ME [(R*"U5(d-XR.- nU=RFUR.- sl#[(R*"U5(a[RO[Tn U "XURFURBUR5Ul+URFR$SUl,U$)aCompute bisecting k-means clustering. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training instances to cluster. .. note:: The data will be converted to C ordering, which will cause a memory copy if the given data is not C-contiguous. y : Ignored Not used, present here for API consistency by convention. sample_weight : array-like of shape (n_samples,), default=None The weights for each observation in X. If None, all observations are assigned equal weight. `sample_weight` is not used during initialization if `init` is a callable. Returns ------- self Fitted estimator. csrCF) accept_sparsedtypeordercopyaccept_large_sparserr@rr)axisr$TsquaredN)-r r_float64float32rF_check_params_vs_inputr rJrpr rrrbrGrOrrq_check_mkl_vcompr\rr]r^mean_X_meanrarange_bisecting_treer rar/r{fullint32labels_r`cluster_centers_ enumerater+rrrgrrinertia__n_features_out) rrcyrdrkrvrti cluster_noderes rfitBisectingKMeans.fitjs6   ::rzz* %  ##A&/0A0AB,]QWWM 57 >>W $1(<"6D   ! !!WWQZ 0"6D {{1~~66q6>DL  A .IIaggaj)66q6>  $At4t*+A $ 4 4 J J L  LL] N ,wwqwwqz2RXX> "$//1771:)Fagg V()=)=)I)I)KLOA12LL-- .'3':':D ! !! $!" #'L M{{1~~  A  ! !T\\ 1 !&(kk!nn?. d33T\\4??   $44::1= r"c[U5 URU5n[USS9n[R"U5nUR XUR 5nU$)aPredict which cluster each sample in X belongs to. Prediction is made by going down the hierarchical tree in searching of closest leaf cluster. In the vector quantization literature, `cluster_centers_` is called the code book and each value returned by `predict` is the index of the closest code in the code book. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) New data to predict. Returns ------- labels : ndarray of shape (n_samples,) Index of the cluster each sample belongs to. Tr)r _check_test_datar r_ ones_like_predict_recursiver)rrcrkrdr%s rpredictBisectingKMeans.predictsU(   ! !! $#At4 _5 ((4;O;OP r"cURc;[R"URSUR[R S9$[R "URRURR45n[US5(aX@R- n[UUUURSS9nUS:Hn[R"URSS[R S9nURXX&UR5Xv'URX)X&)UR5Xv)'U$)aPredict recursively by going down the hierarchical tree. Parameters ---------- X : {ndarray, csr_matrix} of shape (n_samples, n_features) The data points, currently assigned to `cluster_node`, to predict between the subclusters of this node. sample_weight : ndarray of shape (n_samples,) The weights for each observation in X. cluster_node : _BisectingTree node object The cluster node of the hierarchical tree. Returns ------- labels : ndarray of shape (n_samples,) Index of the cluster each sample belongs to. rrrF)return_inertiar)rr_rr\rgrvstackrrhasattrrrrbr)rrcrdrr&cluster_labelsmaskr%s rr"BisectingKMeans._predict_recursives(    $771771:|'9'9J J))\..55|7I7I7P7PQR 4 # # || #G9   OO  "Rrxx8.. G](,*;*;  // eHmE*L,>,> u  r"cl>[TU]5nSURlSS/URlU$)NTrr)rP__sklearn_tags__ input_tagssparsetransformer_tagspreserves_dtype)rtagsrQs rr BisectingKMeans.__sklearn_tags__s4w')!%1:I0F- r") rrrqrrbrprGrHrrFrr))NN)r3r4r5r6r7rrIrcallablerrdict__annotations__r rXrhr{rrrrrr8 __classcell__)rQs@rr;r;SsCJ$  , ,$[(34h?Haf=>+ '7!345)+<>O*PQR $D5 ,558 #B@CD5[6[z@1fr"r;) r7rUnumpyr_ scipy.sparserr]baserutils._openmp_helpersrutils._param_validationrrr utils.extmathr utils.validationr r r r _k_means_commonrr_kmeansrrrrrr;r9r"rrsT# ?DD% =2020jLkLr"