0PhKdZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZddlmZddlmZmZmZmZd d lmZmZd d lmZmZmZmZGd d ZGddeZdS)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_limitc*eZdZdZdZdZdZdZdS)_BisectingTreezITree structure representing the hierarchical clusters of BisectingKMeans.cL||_||_||_d|_d|_dS)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 _/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/cluster/_bisect_k_means.py__init__z_BisectingTree.__init__!s+      ct|j|dk|d|d|_t|j|dk|d|d|_d|_dS)z,Split the cluster node into two subclusters.rrrrrN)rrrr)rlabelscentersscoress rsplitz_BisectingTree.split.sq"L1-gajq     $L1-gajq      r cdd}|D]}| |j|kr |j}|}|S)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_bisectz$_BisectingTree.get_cluster_to_bisect:sL  ,,.. 1 1L L$6$B$B(. $0!  r c#K|j|VdS|jEd{V|jEd{VdS)z0Iterate over all the cluster leaves in the tree.N)rr(r)rs rr(z_BisectingTree.iter_leavesJsm 9 JJJJJy,,.. . . . . . . .z--// / / / / / / / / /r N)__name__ __module__ __qualname____doc__rr&r,r(r rrrsVSS      !!! 00000r rc &eZdZUdZiejeddhegee dddgdged d hged d hgd Ze e d< ddddddddd d d fd Z dZ dZdZedddZdZdZfdZxZS) BisectingKMeansaBisecting 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) r<r= random_statemax_iterverbosetolr>r?r@c t|||||||||_| |_| |_dS)N) n_clustersr<rDrErCrFr=)superrr>r?r@) rrHr<r=rCrDrErFr>r?r@ __class__s rrzBisectingKMeans.__init__sY !%     ""4r c6tjd|ddS)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_vcompzBisectingKMeans._warn_mkl_vcomps9  =*: = = =     r c |jd}tj|rtnt}t j|}t|D]}||||||j|||<|S)aCalculate 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_weightrH_inertiainertia_per_clusterlabels r_inertia_per_clusterz$BisectingKMeans._inertia_per_clusters,]1% &(k!nnH??. hz22:&&  E)1='64?QV***  & &#"r c 0||j}||j}||j}d}t|jD]m}||||j|jd|}|||||j|j|j |j \}} } }| | |dzkr|} | } | }n|jrtd| |j dkr| || | |} ntj| d} || | | dS) 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_normsr<rC n_centroidsr[)rDrErF n_threadsg !?zNew centroids from bisection: r:) minlength)rrXr=_init_centroidsr< _random_state_kmeans_singlerDrErFrYprintr@r_rVbincountr&)rrZrar[cluster_to_bisect best_inertia_ centers_initr#inertiar$ best_labels best_centersr%s r_bisectzBisectingKMeans._bisect(sm" ' ()*;*CD%&7&?@  t{## ' 'A// /Y!/+ 0L+/*=*= H/+>++ 'FGWa#w1J'J'J$ & & < C A<AA B B B  "&7 7 7..<mFF [:::F \6BBBBBr )prefer_skip_nested_validationc t||dtjtjgd|jd}||t |j|_t|||j }t|_ |j dks |jdkr.t|_|||jdn t&|_t)j|s%|d |_||jz}t1tj|jd|d d |_t7|d }t9|jdz D]3}|j}|||||4tj|jdd tj |_!tj"|j|jdf|j |_#tI|j%D]1\}}||j!|j&<|j'|j#|<||_(d|_&2t)j|s||jz }|xj#|jz c_#t)j|rtRntT} | |||j#|j!|j |_+|j#jd|_,|S)a+Compute 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_sparserwr8rr)axisr"TsquaredN)-r rVfloat64float32r>_check_params_vs_inputr rCrfr rwrrYr?rHrrg_check_mkl_vcomprSrrTrUmean_X_meanrarange_bisecting_treer rXr,rqfullint32labels_rWcluster_centers_ enumerater(rrr^rrinertia__n_features_out) rrZyr[rarlrji cluster_noder\s rfitzBisectingKMeans.fitjs6   :rz* %    ##A&&&/0ABB,]AQWMMM 577 >W $ $1(<(<"6D   ! !!QWQZ 0 0 0 0"6D {1~~ 66q6>>DL  A .Iagaj))66q6>>    $At444t*++ O OA $ 4 J J L L  LLO]>> "$/171:)Fag V V V()=)I)I)K)KLL ( (OA|12DL- .'3':D !! $!"L #'L {1~~ 2  A  ! !T\ 1 ! !&(k!nnH??.  }d3T\4?    $4:1= r ct|||}t|d}tj|}||||j}|S)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 rV ones_like_predict_recursiver)rrZrar[r#s rpredictzBisectingKMeans.predictsg(   ! !! $ $#At444 _55 ((M4;OPP r cF|j1tj|jd|jtjStj|jj|jjf}t|dr ||j z }t||||j d}|dk}tj|jddtj}| |||||j||<| |||||j||<|S)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. Nrr{rF)return_inertiar)rrVrrSr^rvstackrrhasattrrrrYr)rrZr[rr$cluster_labelsmaskr#s rrz"BisectingKMeans._predict_recursives'(   $7171:|'9JJJ J)\.5|7I7PQRR 4 # # $ t| #G9   O    "Rrx888.. dG]4(,*;  t // teHmTE*L,>  u  r c|t}d|j_ddg|j_|S)NTrr)rI__sklearn_tags__ input_tagssparsetransformer_tagspreserves_dtype)rtagsrJs rrz BisectingKMeans.__sklearn_tags__s7ww''))!%1:I0F- r )rB)NN)r.r/r0r1rrArcallablerrdict__annotations__rrPr_rqrrrrr __classcell__)rJs@rr4r4SsCCJ$  ,$[(344h?8Haf===>+ j'7!3445)z+<>O*PQQR $$$D5 ,55555558   ###B@C@C@CD\555[[[65[z@111fr r4) r1rMnumpyrV scipy.sparserrTbaserutils._openmp_helpersrutils._param_validationrrr utils.extmathr utils.validationr r r r _k_means_commonrr_kmeansrrrrrr4r2r rrs## ??????DDDDDDDDDD%%%%%% =<<<<<<<2020202020202020jLLLLLkLLLLLr